Variable SyncParametricAssertionsConst

SyncParametricAssertions: readonly [
    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,
        ],
    >,
] = ...