Function use

use<
    MixedAssertions extends readonly AnyAssertion[],
    ExtendedSyncAssertions extends readonly [] | readonly [AnySyncAssertion],
    ExtendedAsyncAssertions extends readonly [] | readonly [AnyAsyncAssertion],
>(
    assertions: MixedAssertions,
): Bupkis<
    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<Map<unknown, unknown>, Map<unknown, unknown>>,
                readonly ["to deep equal", "to deeply equal"],
                ZodUnknown,
            ],
            (
                _: Map<unknown, unknown>,
                expected: unknown,
            ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
            readonly [
                ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
                ZodUnknown,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                readonly ["to deep equal", "to deeply equal"],
                ZodUnknown,
            ],
            (
                _: Set<unknown>,
                expected: unknown,
            ) => ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
            readonly [
                ZodCustom<Set<unknown>, Set<unknown>>,
                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,
            ],
        >,
    ],
    ExtendedSyncAssertions,
    ExtendedAsyncAssertions,
>