Variable SyncBasicAssertionsConst

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