Variable SyncCollectionAssertionsConst

SyncCollectionAssertions: 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,
        ) => { 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,
        ) => { 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 item satisfying",
                "to have an item satisfying",
                "to contain item satisfying",
            ],
            ZodUnknown,
        ],
        (subject: unknown[], shape: unknown) => { message: string } | undefined,
        readonly [
            ZodArray<ZodUnknown>,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have item satisfying",
                    "to have an item satisfying",
                    "to contain item satisfying",
                ],
            >,
            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>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                    ZodArray<ZodUnknown>,
                ],
            >,
            readonly ["to have values satisfying", "to contain values satisfying"],
            ZodUnknown,
        ],
        (
            subject: unknown[] | Map<unknown, unknown> | Set<unknown>,
            expected: unknown,
        ) => { message: string } | undefined,
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                    ZodArray<ZodUnknown>,
                ],
            >,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have values satisfying",
                    "to contain values satisfying",
                ],
            >,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                    ZodArray<ZodUnknown>,
                ],
            >,
            "to have values exhaustively satisfying",
            ZodUnknown,
        ],
        (
            subject: unknown[] | Map<unknown, unknown> | Set<unknown>,
            expected: unknown,
        ) => { message: string } | undefined,
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                    ZodArray<ZodUnknown>,
                ],
            >,
            PhraseLiteralSlot<"to have values exhaustively satisfying">,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                    ZodArray<ZodUnknown>,
                ],
            >,
            readonly [
                "to have a value satisfying",
                "to have value satisfying",
                "to contain a value satisfying",
            ],
            ZodUnknown,
        ],
        (
            subject: unknown[] | Map<unknown, unknown> | Set<unknown>,
            expected: unknown,
        ) => { message: string } | undefined,
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                    ZodArray<ZodUnknown>,
                ],
            >,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have a value satisfying",
                    "to have value satisfying",
                    "to contain a value satisfying",
                ],
            >,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                    ZodArray<ZodUnknown>,
                ],
            >,
            readonly [
                "to have a value exhaustively satisfying",
                "to have value exhaustively satisfying",
            ],
            ZodUnknown,
        ],
        (
            subject: unknown[] | Map<unknown, unknown> | Set<unknown>,
            expected: unknown,
        ) => { message: string } | undefined,
        readonly [
            ZodUnion<
                readonly [
                    ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    ZodCustom<Set<unknown>, Set<unknown>>,
                    ZodArray<ZodUnknown>,
                ],
            >,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have a value exhaustively satisfying",
                    "to have value exhaustively satisfying",
                ],
            >,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            readonly [
                "to have keys satisfying",
                "to have props satisfying",
                "to have properties satisfying",
                "to have fields satisfying",
                "to contain keys satisfying",
                "to contain props satisfying",
                "to contain properties satisfying",
                "to contain fields satisfying",
            ],
            ZodUnknown,
        ],
        (
            subject: Map<unknown, unknown>,
            expected: unknown,
        ) => { message: string } | undefined,
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have keys satisfying",
                    "to have props satisfying",
                    "to have properties satisfying",
                    "to have fields satisfying",
                    "to contain keys satisfying",
                    "to contain props satisfying",
                    "to contain properties satisfying",
                    "to contain fields satisfying",
                ],
            >,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            readonly [
                "to have keys exhaustively satisfying",
                "to have props exhaustively satisfying",
                "to have properties exhaustively satisfying",
                "to have fields exhaustively satisfying",
            ],
            ZodUnknown,
        ],
        (
            subject: Map<unknown, unknown>,
            expected: unknown,
        ) => { message: string } | undefined,
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have keys exhaustively satisfying",
                    "to have props exhaustively satisfying",
                    "to have properties exhaustively satisfying",
                    "to have fields exhaustively satisfying",
                ],
            >,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            readonly [
                "to have a key satisfying",
                "to have key satisfying",
                "to have a prop satisfying",
                "to have prop satisfying",
                "to have a property satisfying",
                "to have property satisfying",
                "to have a field satisfying",
                "to have field satisfying",
            ],
            ZodUnknown,
        ],
        (
            subject: Map<unknown, unknown>,
            expected: unknown,
        ) => { message: string } | undefined,
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have a key satisfying",
                    "to have key satisfying",
                    "to have a prop satisfying",
                    "to have prop satisfying",
                    "to have a property satisfying",
                    "to have property satisfying",
                    "to have a field satisfying",
                    "to have field satisfying",
                ],
            >,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            readonly [
                "to have a key exhaustively satisfying",
                "to have key exhaustively satisfying",
                "to have a prop exhaustively satisfying",
                "to have prop exhaustively satisfying",
                "to have a property exhaustively satisfying",
                "to have property exhaustively satisfying",
                "to have a field exhaustively satisfying",
                "to have field exhaustively satisfying",
            ],
            ZodUnknown,
        ],
        (
            subject: Map<unknown, unknown>,
            expected: unknown,
        ) => { message: string } | undefined,
        readonly [
            ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have a key exhaustively satisfying",
                    "to have key exhaustively satisfying",
                    "to have a prop exhaustively satisfying",
                    "to have prop exhaustively satisfying",
                    "to have a property exhaustively satisfying",
                    "to have property exhaustively satisfying",
                    "to have a field exhaustively satisfying",
                    "to have field exhaustively satisfying",
                ],
            >,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            readonly [
                "to have keys satisfying",
                "to have props satisfying",
                "to have properties satisfying",
                "to have fields satisfying",
            ],
            ZodUnknown,
        ],
        (
            subject: Record<PropertyKey, unknown> | ((...args: any[]) => any),
            expected: unknown,
        ) => { message: string } | undefined,
        readonly [
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have keys satisfying",
                    "to have props satisfying",
                    "to have properties satisfying",
                    "to have fields satisfying",
                ],
            >,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            readonly [
                "to have a key satisfying",
                "to have key satisfying",
                "to have a prop satisfying",
                "to have prop satisfying",
                "to have a property satisfying",
                "to have property satisfying",
                "to have a field satisfying",
                "to have field satisfying",
            ],
            ZodUnknown,
        ],
        (
            subject: Record<PropertyKey, unknown> | ((...args: any[]) => any),
            expected: unknown,
        ) => { message: string } | undefined,
        readonly [
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have a key satisfying",
                    "to have key satisfying",
                    "to have a prop satisfying",
                    "to have prop satisfying",
                    "to have a property satisfying",
                    "to have property satisfying",
                    "to have a field satisfying",
                    "to have field satisfying",
                ],
            >,
            ZodUnknown,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            readonly [
                "to have keys matching",
                "to have props matching",
                "to have properties matching",
                "to have fields matching",
            ],
            ZodCustom<RegExp, RegExp>,
        ],
        (
            subject: Record<PropertyKey, unknown> | ((...args: any[]) => any),
            pattern: RegExp,
        ) => { message: string } | undefined,
        readonly [
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have keys matching",
                    "to have props matching",
                    "to have properties matching",
                    "to have fields matching",
                ],
            >,
            ZodCustom<RegExp, RegExp>,
        ],
    >,
    AssertionFunctionSync<
        readonly [
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            readonly [
                "to have a key matching",
                "to have key matching",
                "to have a prop matching",
                "to have prop matching",
                "to have a property matching",
                "to have property matching",
                "to have a field matching",
                "to have field matching",
            ],
            ZodCustom<RegExp, RegExp>,
        ],
        (
            subject: Record<PropertyKey, unknown> | ((...args: any[]) => any),
            pattern: RegExp,
        ) => { message: string } | undefined,
        readonly [
            ZodCustom<
                Record<PropertyKey, unknown>
                | ((...args: any[]) => any),
                Record<PropertyKey, unknown> | ((...args: any[]) => any),
            >,
            PhraseLiteralChoiceSlot<
                readonly [
                    "to have a key matching",
                    "to have key matching",
                    "to have a prop matching",
                    "to have prop matching",
                    "to have a property matching",
                    "to have property matching",
                    "to have a field matching",
                    "to have field matching",
                ],
            >,
            ZodCustom<RegExp, RegExp>,
        ],
    >,
] = ...