Variable SyncAssertionsConst

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