BUPKIS
    Preparing search index...

    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,
            ) =>
                | { 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>,
            ],
        >,
    ] = ...

    Settings

    Member Visibility