bupkis 0.18.2 → 1.0.0

package/dist/assertion/impl/sync-collection.d.ts

@@ -0,0 +1,922 @@
+import { z } from 'zod';
+/**
+ * Asserts that a Map or WeakMap contains a specific key. For WeakMap, the key
+ * must be an object.
+ *
+ * @example
+ *
+ * ```ts
+ * const map = new Map([['key', 'value']]);
+ * expect(map, 'to contain', 'key'); // passes
+ *
+ * const obj = {};
+ * const weakMap = new WeakMap([[obj, 'value']]);
+ * expect(weakMap, 'to contain', obj); // passes
+ * expect(weakMap, 'to contain', 'string'); // fails (not an object)
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor map-to-contain-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const mapContainsAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: Map<unknown, unknown> | WeakMap<WeakKey, unknown>, key: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>;
+/**
+ * Asserts that a Map has a specific size.
+ *
+ * @example
+ *
+ * ```ts
+ * const map = new Map([
+ *   ['a', 1],
+ *   ['b', 2],
+ * ]);
+ * expect(map, 'to have size', 2); // passes
+ * expect(map, 'to have size', 3); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor map-to-have-size-nonnegative-integer
+ * @bupkisAssertionCategory collections
+ */
+export declare const mapSizeAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", z.ZodInt], (_subject: Map<unknown, unknown>, expectedSize: number) => z.ZodMap<z.ZodUnknown, z.ZodUnknown>, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>;
+/**
+ * Asserts that a Map is empty.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new Map(), 'to be empty'); // passes
+ * expect(new Map([['key', 'value']]), 'to be empty'); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor map-to-be-empty
+ * @bupkisAssertionCategory collections
+ */
+export declare const emptyMapAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
+/**
+ * Asserts that a Set or WeakSet contains a specific value. For WeakSet, the
+ * value must be an object.
+ *
+ * @example
+ *
+ * ```ts
+ * const set = new Set(['a', 'b']);
+ * expect(set, 'to contain', 'a'); // passes
+ *
+ * const obj = {};
+ * const weakSet = new WeakSet([obj]);
+ * expect(weakSet, 'to contain', obj); // passes
+ * expect(weakSet, 'to contain', 'string'); // fails (not an object)
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor set-to-contain-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const setContainsAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<[z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>;
+/**
+ * Asserts that a Set has a specific size.
+ *
+ * @example
+ *
+ * ```ts
+ * const set = new Set(['a', 'b']);
+ * expect(set, 'to have size', 2); // passes
+ * expect(set, 'to have size', 3); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor set-to-have-size-nonnegative-integer
+ * @bupkisAssertionCategory collections
+ */
+export declare const setSizeAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have size", z.ZodInt], (_subject: Set<unknown>, expectedSize: number) => z.ZodSet<z.ZodUnknown>, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>;
+/**
+ * Asserts that a Set is empty.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new Set(), 'to be empty'); // passes
+ * expect(new Set(['value']), 'to be empty'); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor set-to-be-empty
+ * @bupkisAssertionCategory collections
+ */
+export declare const emptySetAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], z.ZodCustom<Set<unknown>, Set<unknown>>, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
+/**
+ * Asserts that an array contains a specific value.
+ *
+ * @example
+ *
+ * ```ts
+ * expect([1, 2, 3], 'to contain', 2); // passes
+ * expect([1, 2, 3], 'to contain', 4); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor array-to-contain-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const arrayContainsAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: unknown[], value: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodArray<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>;
+/**
+ * Asserts that an array contains an item that satisfies a given shape or
+ * pattern. Uses partial matching semantics - the item only needs to match the
+ * specified properties.
+ *
+ * @example
+ *
+ * ```ts
+ * expect([{ a: 1, b: 2 }, { c: 3 }], 'to have item satisfying', { a: 1 }); // passes
+ * expect([{ a: 1 }, { b: 2 }], 'to have an item satisfying', { c: 3 }); // fails
+ * expect([1, 2, 3], 'to contain item satisfying', 2); // passes (exact match)
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor array-to-have-item-satisfying
+ * @bupkisAssertionCategory collections
+ */
+export declare const arrayItemSatisfiesAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, readonly ["to have item satisfying", "to have an item satisfying", "to contain item satisfying"], z.ZodUnknown], (subject: unknown[], shape: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodArray<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have item satisfying", "to have an item satisfying", "to contain item satisfying"]>, z.ZodUnknown]>;
+/**
+ * Asserts that an array has a specific size.
+ *
+ * @example
+ *
+ * ```ts
+ * expect([1, 2, 3], 'to have length', 3); // passes
+ * expect([1, 2, 3], 'to have size', 2); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor array-to-have-size-nonnegative-integer
+ * @bupkisAssertionCategory collections
+ */
+export declare const arraySizeAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, readonly ["to have length", "to have size"], z.ZodInt], (_subject: unknown[], expectedSize: number) => z.ZodArray<z.ZodUnknown>, readonly [z.ZodArray<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>, z.ZodInt]>;
+/**
+ * Asserts that an array is non-empty.
+ *
+ * @example
+ *
+ * ```ts
+ * expect([1, 2, 3], 'to be non-empty'); // passes
+ * expect([], 'to be non-empty'); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor array-not-to-be-empty
+ * @bupkisAssertionCategory collections
+ */
+export declare const nonEmptyArrayAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"], z.ZodArray<z.ZodUnknown>, readonly [z.ZodArray<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>;
+/**
+ * Asserts that an object has specific keys/properties.
+ *
+ * @example
+ *
+ * ```ts
+ * expect({ a: 1, b: 2 }, 'to have keys', 'a', 'b'); // passes
+ * expect({ a: 1 }, 'to have keys', 'a', 'b'); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor object-to-have-keys-array
+ * @bupkisAssertionCategory object
+ */
+export declare const objectKeysAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.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"], z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>>], (_subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: (string | number | symbol)[]) => z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").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"]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>>]>;
+/**
+ * Asserts that an object has a property at the specified keypath using dot or
+ * bracket notation. Uses the `has()` function to traverse nested properties and
+ * supports complex keypaths like 'foo.bar[0]["baz"]'.
+ *
+ * This assertion supports:
+ *
+ * - Dot notation: 'prop.nested'
+ * - Bracket notation with numbers: 'arr[0]'
+ * - Bracket notation with quoted strings: 'obj["key"]' or "obj['key']"
+ * - Mixed notation: 'data.items[1].name'
+ *
+ * @example
+ *
+ * ```ts
+ * const obj = {
+ *   foo: { bar: [{ baz: 'value' }] },
+ *   'kebab-case': 'works',
+ * };
+ *
+ * expect(obj, 'to have key', 'foo.bar'); // passes
+ * expect(obj, 'to have property', 'foo.bar[0].baz'); // passes
+ * expect(obj, 'to have prop', 'foo["kebab-case"]'); // passes
+ * expect(obj, 'to have key', 'nonexistent.path'); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor object-to-have-key-string-number-symbol
+ * @bupkisAssertionCategory object
+ */
+export declare const objectKeyAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.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"], z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keypath: string) => {
+    actual: string;
+    expect: string;
+    message: string;
+} | undefined, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").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"]>, z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>]>;
+/**
+ * Asserts that an object has an exact property key without keypath traversal.
+ * This assertion checks for direct properties on the object and supports
+ * symbols and keys that would conflict with bracket/dot notation.
+ *
+ * Unlike `objectKeyAssertion`, this does not use the `has()` function and
+ * therefore:
+ *
+ * - Does not support keypath traversal (no dots or brackets)
+ * - Can check for symbol keys
+ * - Can check for keys containing dots, brackets, or other special characters
+ * - Only checks direct properties (no nested access)
+ *
+ * @example
+ *
+ * ```ts
+ * const sym = Symbol('test');
+ * const obj = {
+ *   simple: 'value',
+ *   'key.with.dots': 'direct property',
+ *   'key[with]brackets': 'another direct property',
+ *   [sym]: 'symbol value',
+ * };
+ *
+ * expect(obj, 'to have exact key', 'simple'); // passes
+ * expect(obj, 'to have exact property', 'key.with.dots'); // passes (literal key)
+ * expect(obj, 'to have exact prop', 'key[with]brackets'); // passes (literal key)
+ * expect(obj, 'to have exact key', sym); // passes (symbol key)
+ *
+ * // These would fail because they're not direct properties:
+ * expect(obj, 'to have exact key', 'nested.path'); // fails (no keypath traversal)
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor object-to-have-only-keys-array
+ * @bupkisAssertionCategory object
+ */
+export declare const objectExactKeyAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.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"], z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>], (_: Record<PropertyKey, unknown> | ((...args: any[]) => any), key: string | number | symbol) => z.ZodPipe<z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, z.ZodTransform<{}, Record<PropertyKey, unknown> | ((...args: any[]) => any)>>, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have exact key", "to have exact property", "to have exact prop"]>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>]>;
+/**
+ * Asserts that an object has a specific number of keys.
+ *
+ * @example
+ *
+ * ```ts
+ * expect({ a: 1, b: 2 }, 'to have size', 2); // passes
+ * expect({ a: 1 }, 'to have size', 2); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor unknown-to-be-an-object
+ * @bupkisAssertionCategory object
+ */
+export declare const objectSizeAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, "to have size", z.ZodInt], (subject: Record<string | number | symbol, unknown>, expectedSize: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>;
+/**
+ * Asserts that two Sets are equal (same elements, order-independent).
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new Set([1, 2]), 'to equal', new Set([2, 1])); // passes
+ * expect(new Set([1, 2]), 'to equal', new Set([1, 3])); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor set-to-equal-set
+ * @bupkisAssertionCategory collections
+ */
+export declare const setEqualityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to equal", z.ZodCustom<Set<unknown>, Set<unknown>>], (actual: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to equal">, z.ZodCustom<Set<unknown>, Set<unknown>>]>;
+/**
+ * Asserts that one Set is a subset of another.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new Set([1, 2]), 'to be a subset of', new Set([1, 2, 3])); // passes
+ * expect(new Set([1, 4]), 'to be a subset of', new Set([1, 2, 3])); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor set-to-be-a-subset-of-set
+ * @bupkisAssertionCategory collections
+ */
+export declare const setSubsetAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be a subset of", z.ZodCustom<Set<unknown>, Set<unknown>>], (subset: Set<unknown>, superset: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be a subset of">, z.ZodCustom<Set<unknown>, Set<unknown>>]>;
+/**
+ * Asserts that one Set is a superset of another.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new Set([1, 2, 3]), 'to be a superset of', new Set([1, 2])); // passes
+ * expect(new Set([1, 2]), 'to be a superset of', new Set([1, 2, 3])); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor set-to-be-a-superset-of-set
+ * @bupkisAssertionCategory collections
+ */
+export declare const setSupersetAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be a superset of", z.ZodCustom<Set<unknown>, Set<unknown>>], (superset: Set<unknown>, subset: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be a superset of">, z.ZodCustom<Set<unknown>, Set<unknown>>]>;
+/**
+ * Asserts that two Sets intersect (have common elements).
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new Set([1, 2]), 'to intersect with', new Set([2, 3])); // passes
+ * expect(new Set([1, 2]), 'to intersect with', new Set([3, 4])); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor set-to-have-intersection-with-set-satisfying-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const setIntersectionAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to intersect with", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to intersect with">, z.ZodCustom<Set<unknown>, Set<unknown>>]>;
+/**
+ * Asserts that two Sets are disjoint (have no common elements).
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new Set([1, 2]), 'to be disjoint from', new Set([3, 4])); // passes
+ * expect(new Set([1, 2]), 'to be disjoint from', new Set([2, 3])); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor set-to-be-disjoint-from-set
+ * @bupkisAssertionCategory collections
+ */
+export declare const setDisjointAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be disjoint from", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be disjoint from">, z.ZodCustom<Set<unknown>, Set<unknown>>]>;
+/**
+ * Asserts that the union of two Sets equals a third Set.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(
+ *   new Set([1, 2]),
+ *   'to have union',
+ *   new Set([3]),
+ *   'equal to',
+ *   new Set([1, 2, 3]),
+ * ); // passes
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor set-union-with-set-to-equal-set
+ * @bupkisAssertionCategory collections
+ */
+export declare const setUnionEqualityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have union", z.ZodCustom<Set<unknown>, Set<unknown>>, "equal to", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have union">, z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, z.ZodCustom<Set<unknown>, Set<unknown>>]>;
+/**
+ * Asserts that the intersection of two Sets equals a third Set.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(
+ *   new Set([1, 2, 3]),
+ *   'to have intersection',
+ *   new Set([2, 3, 4]),
+ *   'equal to',
+ *   new Set([2, 3]),
+ * ); // passes
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor set-intersection-with-set-to-equal-set
+ * @bupkisAssertionCategory collections
+ */
+export declare const setIntersectionEqualityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have intersection", z.ZodCustom<Set<unknown>, Set<unknown>>, "equal to", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have intersection">, z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, z.ZodCustom<Set<unknown>, Set<unknown>>]>;
+/**
+ * Asserts that the difference between two Sets equals a third Set.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(
+ *   new Set([1, 2, 3]),
+ *   'to have difference',
+ *   new Set([2, 4]),
+ *   'equal to',
+ *   new Set([1, 3]),
+ * ); // passes
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor set-difference-with-set-to-equal-set
+ * @bupkisAssertionCategory collections
+ */
+export declare const setDifferenceEqualityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have difference", z.ZodCustom<Set<unknown>, Set<unknown>>, "equal to", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have difference">, z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, z.ZodCustom<Set<unknown>, Set<unknown>>]>;
+/**
+ * Asserts that the symmetric difference between two Sets equals a third Set.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(
+ *   new Set([1, 2]),
+ *   'to have symmetric difference',
+ *   new Set([2, 3]),
+ *   'equal to',
+ *   new Set([1, 3]),
+ * ); // passes
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor set-symmetric-difference-with-set-to-equal-set
+ * @bupkisAssertionCategory collections
+ */
+export declare const setSymmetricDifferenceEqualityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have symmetric difference", z.ZodCustom<Set<unknown>, Set<unknown>>, "equal to", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have symmetric difference">, z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, z.ZodCustom<Set<unknown>, Set<unknown>>]>;
+/**
+ * Asserts that a Map has a specific key.
+ *
+ * @example
+ *
+ * ```ts
+ * const map = new Map([['key', 'value']]);
+ * expect(map, 'to have key', 'key'); // passes
+ * expect(map, 'to have key', 'missing'); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor map-to-have-key-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const mapKeyAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have key", z.ZodUnknown], (map: Map<unknown, unknown>, key: unknown) => {
+    actual: unknown[];
+    expected: unknown[];
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have key">, z.ZodUnknown]>;
+/**
+ * Asserts that a Map contains a specific value.
+ *
+ * @example
+ *
+ * ```ts
+ * const map = new Map([['key', 'value']]);
+ * expect(map, 'to have value', 'value'); // passes
+ * expect(map, 'to have value', 'missing'); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor map-to-have-value-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const mapValueAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have value", "to contain value", "to include value"], z.ZodUnknown], (map: Map<unknown, unknown>, value: unknown) => {
+    actual: unknown[];
+    expected: unknown;
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have value", "to contain value", "to include value"]>, z.ZodUnknown]>;
+/**
+ * Asserts that a Map has a specific key-value entry.
+ *
+ * @example
+ *
+ * ```ts
+ * const map = new Map([['key', 'value']]);
+ * expect(map, 'to have entry', ['key', 'value']); // passes
+ * expect(map, 'to have entry', ['key', 'wrong']); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor map-to-have-entry-any-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const mapEntryAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.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"], z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>], (map: Map<unknown, unknown> | WeakMap<WeakKey, unknown>, [key, value]: [unknown, unknown]) => {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: unknown[] | undefined;
+    expected: unknown[];
+    message: string;
+} | undefined, readonly [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("../assertion-types.js").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"]>, z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>]>;
+/**
+ * Asserts that two Maps are equal (same key-value pairs, order-independent).
+ *
+ * @example
+ *
+ * ```ts
+ * const map1 = new Map([
+ *   ['a', 1],
+ *   ['b', 2],
+ * ]);
+ * const map2 = new Map([
+ *   ['b', 2],
+ *   ['a', 1],
+ * ]);
+ * expect(map1, 'to equal', map2); // passes
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor map-to-equal-map
+ * @bupkisAssertionCategory collections
+ */
+export declare const mapEqualityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to equal", z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>], (mapA: Map<unknown, unknown>, mapB: Map<unknown, unknown>) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: unknown[];
+    expected: unknown[];
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to equal">, z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>]>;
+/**
+ * Asserts that a collection (Map or Set) has a size greater than a threshold.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new Set([1, 2, 3]), 'to have size greater than', 2); // passes
+ * expect(new Set([1]), 'to have size greater than', 2); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor collection-to-have-size-greater-than-nonnegative-integer
+ * @bupkisAssertionCategory collections
+ */
+export declare const collectionSizeGreaterThanAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size greater than", z.ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, minSize: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size greater than">, z.ZodInt]>;
+/**
+ * Asserts that a collection (Map or Set) has a size less than a threshold.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new Set([1]), 'to have size less than', 2); // passes
+ * expect(new Set([1, 2, 3]), 'to have size less than', 2); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor collection-to-have-size-less-than-nonnegative-integer
+ * @bupkisAssertionCategory collections
+ */
+export declare const collectionSizeLessThanAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size less than", z.ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, maxSize: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size less than">, z.ZodInt]>;
+/**
+ * Asserts that a collection (Map or Set) has a size within a specific range.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(new Set([1, 2]), 'to have size between', [1, 3]); // passes
+ * expect(new Set([1, 2, 3, 4]), 'to have size between', [1, 3]); // fails
+ * ```
+ *
+ * @group Collection Assertions
+ * @bupkisAnchor collection-to-have-size-between-nonnegative-integer-and-nonnegative-integer
+ * @bupkisAssertionCategory collections
+ */
+export declare const collectionSizeBetweenAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size between", z.ZodTuple<[z.ZodInt, z.ZodInt], null>], (collection: Map<unknown, unknown> | Set<unknown>, [min, max]: [number, number]) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size between">, z.ZodTuple<[z.ZodInt, z.ZodInt], null>]>;
+/**
+ * Asserts that ALL values in a Map, Set, or Array individually satisfy the
+ * expected shape.
+ *
+ * Uses partial/satisfy semantics — every value must match. Empty collections
+ * pass vacuously.
+ *
+ * @remarks
+ * For `Map`, values (not keys) are checked. Use `mapKeysSatisfyAssertion` to
+ * assert on Map keys instead.
+ * @example
+ *
+ * ```ts
+ * expect([{ a: 1 }, { a: 2, b: 3 }], 'to have values satisfying', {
+ *   a: z.number(),
+ * }); // passes
+ * expect(new Set([1, 2, 3]), 'to have values satisfying', z.number()); // passes
+ * expect(new Map([['k', { x: 1 }]]), 'to have values satisfying', {
+ *   x: z.number(),
+ * }); // passes
+ * ```
+ *
+ * @function
+ * @group Collection Assertions
+ * @bupkisAnchor collection-to-have-values-satisfying-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const collectionValuesSatisfyAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, readonly ["to have values satisfying", "to contain values satisfying"], z.ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have values satisfying", "to contain values satisfying"]>, z.ZodUnknown]>;
+/**
+ * Asserts that ALL values in a Map, Set, or Array individually match with deep
+ * equality.
+ *
+ * Uses strict deep-equality semantics — every value must exactly match. Empty
+ * collections pass vacuously.
+ *
+ * @example
+ *
+ * ```ts
+ * expect([{ a: 1 }, { a: 1 }], 'to have values exhaustively satisfying', {
+ *   a: 1,
+ * }); // passes
+ * expect([{ a: 1, b: 2 }], 'to have values exhaustively satisfying', {
+ *   a: 1,
+ * }); // fails — extra property b
+ * ```
+ *
+ * @function
+ * @group Collection Assertions
+ * @bupkisAnchor collection-to-have-values-exhaustively-satisfying-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const collectionValuesExhaustivelySatisfyAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, "to have values exhaustively satisfying", z.ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have values exhaustively satisfying">, z.ZodUnknown]>;
+/**
+ * Asserts that at least one value in a Map, Set, or Array satisfies the
+ * expected shape.
+ *
+ * Uses partial/satisfy semantics — any single matching value is sufficient.
+ * Fails on empty collections.
+ *
+ * @remarks
+ * For `Map`, values (not keys) are checked.
+ * @example
+ *
+ * ```ts
+ * expect([{ a: 1, b: 2 }, { c: 3 }], 'to have a value satisfying', {
+ *   a: 1,
+ * }); // passes
+ * expect(new Set([1, 'two', 3]), 'to have a value satisfying', z.string()); // passes
+ * expect([1, 2, 3], 'to have value satisfying', 2); // passes
+ * ```
+ *
+ * @function
+ * @group Collection Assertions
+ * @bupkisAnchor collection-to-have-a-value-satisfying-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const collectionHasValueSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, readonly ["to have a value satisfying", "to have value satisfying", "to contain a value satisfying"], z.ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a value satisfying", "to have value satisfying", "to contain a value satisfying"]>, z.ZodUnknown]>;
+/**
+ * Asserts that at least one value in a Map, Set, or Array exhaustively matches
+ * the expected value.
+ *
+ * Uses strict deep-equality semantics. Fails on empty collections.
+ *
+ * @example
+ *
+ * ```ts
+ * expect(
+ *   [{ a: 1 }, { a: 1, b: 2 }],
+ *   'to have a value exhaustively satisfying',
+ *   {
+ *     a: 1,
+ *   },
+ * ); // passes — first element matches exactly
+ * expect([{ a: 1, b: 2 }], 'to have a value exhaustively satisfying', {
+ *   a: 1,
+ * }); // fails — extra property b
+ * ```
+ *
+ * @function
+ * @group Collection Assertions
+ * @bupkisAnchor collection-to-have-a-value-exhaustively-satisfying-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const collectionHasValueExhaustivelySatisfyingAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, readonly ["to have a value exhaustively satisfying", "to have value exhaustively satisfying"], z.ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a value exhaustively satisfying", "to have value exhaustively satisfying"]>, z.ZodUnknown]>;
+/**
+ * Asserts that ALL keys in a Map individually satisfy the expected shape.
+ *
+ * Uses partial/satisfy semantics — every key must match. Empty Maps pass
+ * vacuously.
+ *
+ * @example
+ *
+ * ```ts
+ * const map = new Map([
+ *   ['foo', 1],
+ *   ['bar', 2],
+ * ]);
+ * expect(map, 'to have keys satisfying', z.string()); // passes
+ * expect(map, 'to have props satisfying', z.string()); // alias — same assertion
+ * expect(map, 'to have fields satisfying', z.string()); // alias
+ * expect(map, 'to contain keys satisfying', /^[a-z]+$/); // alias
+ * ```
+ *
+ * @function
+ * @group Collection Assertions
+ * @bupkisAnchor map-to-have-keys-satisfying-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const mapKeysSatisfyAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.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"], z.ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").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"]>, z.ZodUnknown]>;
+/**
+ * Asserts that ALL keys in a Map individually match with deep equality.
+ *
+ * Uses strict deep-equality semantics — every key must exactly match. Empty
+ * Maps pass vacuously.
+ *
+ * @example
+ *
+ * ```ts
+ * const map = new Map([
+ *   [{ id: 1 }, 'a'],
+ *   [{ id: 2 }, 'b'],
+ * ]);
+ * expect(map, 'to have keys exhaustively satisfying', { id: z.number() }); // fails — extra strict
+ * expect(map, 'to have props exhaustively satisfying', { id: z.number() }); // alias
+ * expect(map, 'to have fields exhaustively satisfying', {
+ *   id: z.number(),
+ * }); // alias
+ * ```
+ *
+ * @function
+ * @group Collection Assertions
+ * @bupkisAnchor map-to-have-keys-exhaustively-satisfying-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const mapKeysExhaustivelySatisfyAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.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"], z.ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys exhaustively satisfying", "to have props exhaustively satisfying", "to have properties exhaustively satisfying", "to have fields exhaustively satisfying"]>, z.ZodUnknown]>;
+/**
+ * Asserts that at least one key in a Map satisfies the expected shape.
+ *
+ * Uses partial/satisfy semantics. Fails on empty Maps.
+ *
+ * @example
+ *
+ * ```ts
+ * const map = new Map([
+ *   ['foo', 1],
+ *   [42, 2],
+ * ]);
+ * expect(map, 'to have a key satisfying', z.string()); // passes
+ * expect(map, 'to have key satisfying', z.number()); // passes
+ * expect(map, 'to have a prop satisfying', z.string()); // alias
+ * expect(map, 'to have a field satisfying', z.number()); // alias
+ * ```
+ *
+ * @function
+ * @group Collection Assertions
+ * @bupkisAnchor map-to-have-a-key-satisfying-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const mapHasKeySatisfyingAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.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"], z.ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").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"]>, z.ZodUnknown]>;
+/**
+ * Asserts that at least one key in a Map exhaustively matches the expected
+ * value.
+ *
+ * Uses strict deep-equality semantics. Fails on empty Maps.
+ *
+ * @example
+ *
+ * ```ts
+ * const map = new Map([
+ *   [{ id: 1 }, 'a'],
+ *   [{ id: 2 }, 'b'],
+ * ]);
+ * expect(map, 'to have a key exhaustively satisfying', { id: 1 }); // passes
+ * expect(map, 'to have a prop exhaustively satisfying', { id: 1 }); // alias
+ * expect(map, 'to have a field exhaustively satisfying', { id: 2 }); // alias
+ * ```
+ *
+ * @function
+ * @group Collection Assertions
+ * @bupkisAnchor map-to-have-a-key-exhaustively-satisfying-any
+ * @bupkisAssertionCategory collections
+ */
+export declare const mapHasKeyExhaustivelySatisfyingAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.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"], z.ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").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"]>, z.ZodUnknown]>;
+/**
+ * Asserts that ALL own enumerable string keys of a non-collection object
+ * individually satisfy the expected shape.
+ *
+ * Uses partial/satisfy semantics — every key must match. Empty objects pass
+ * vacuously.
+ *
+ * @remarks
+ * Only considers own enumerable string keys (equivalent to `Object.keys()`).
+ * Symbol keys and non-enumerable keys are not checked.
+ * @example
+ *
+ * ```ts
+ * expect({ foo: 1, bar: 2 }, 'to have keys satisfying', z.string()); // passes
+ * expect({ foo: 1, bar: 2 }, 'to have props satisfying', /^[a-z]+$/); // alias
+ * expect({ foo: 1, bar: 2 }, 'to have fields satisfying', /^[a-z]+$/); // alias
+ * expect({ FOO: 1 }, 'to have keys satisfying', /^[a-z]+$/); // fails
+ * ```
+ *
+ * @function
+ * @group Collection Assertions
+ * @bupkisAnchor object-to-have-keys-satisfying-any
+ * @bupkisAssertionCategory object
+ */
+export declare const objectKeysSatisfyAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.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"], z.ZodUnknown], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys satisfying", "to have props satisfying", "to have properties satisfying", "to have fields satisfying"]>, z.ZodUnknown]>;
+/**
+ * Asserts that at least one own enumerable string key of a non-collection
+ * object satisfies the expected shape.
+ *
+ * Uses partial/satisfy semantics. Fails on objects with no own enumerable
+ * string keys.
+ *
+ * @remarks
+ * Only considers own enumerable string keys (equivalent to `Object.keys()`).
+ * Symbol keys and non-enumerable keys are not checked.
+ * @example
+ *
+ * ```ts
+ * expect({ foo: 1, BAR: 2 }, 'to have a key satisfying', /^[a-z]+$/); // passes
+ * expect({ foo: 1 }, 'to have key satisfying', z.string()); // passes
+ * expect({ foo: 1 }, 'to have a prop satisfying', z.string()); // alias
+ * expect({ foo: 1 }, 'to have a field satisfying', z.string()); // alias
+ * ```
+ *
+ * @function
+ * @group Collection Assertions
+ * @bupkisAnchor object-to-have-a-key-satisfying-any
+ * @bupkisAssertionCategory object
+ */
+export declare const objectHasKeySatisfyingAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.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"], z.ZodUnknown], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").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"]>, z.ZodUnknown]>;
+/**
+ * Asserts that ALL own enumerable string keys of a non-collection object match
+ * a regular expression.
+ *
+ * Empty objects pass vacuously.
+ *
+ * @remarks
+ * Only considers own enumerable string keys (equivalent to `Object.keys()`).
+ * Symbol keys and non-enumerable keys are not checked.
+ * @example
+ *
+ * ```ts
+ * expect({ foo: 1, bar: 2 }, 'to have keys matching', /^[a-z]+$/); // passes
+ * expect({ foo: 1, bar: 2 }, 'to have props matching', /^[a-z]+$/); // alias
+ * expect({ foo: 1, bar: 2 }, 'to have fields matching', /^[a-z]+$/); // alias
+ * expect({ foo: 1, Bar: 2 }, 'to have keys matching', /^[a-z]+$/); // fails
+ * expect({}, 'to have keys matching', /anything/); // passes (vacuous)
+ * ```
+ *
+ * @function
+ * @group Collection Assertions
+ * @bupkisAnchor object-to-have-keys-matching-regexp
+ * @bupkisAssertionCategory object
+ */
+export declare const objectKeysMatchAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.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"], z.ZodCustom<RegExp, RegExp>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), pattern: RegExp) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys matching", "to have props matching", "to have properties matching", "to have fields matching"]>, z.ZodCustom<RegExp, RegExp>]>;
+/**
+ * Asserts that at least one own enumerable string key of a non-collection
+ * object matches a regular expression.
+ *
+ * Fails on objects with no own enumerable string keys.
+ *
+ * @remarks
+ * Only considers own enumerable string keys (equivalent to `Object.keys()`).
+ * Symbol keys and non-enumerable keys are not checked.
+ * @example
+ *
+ * ```ts
+ * expect({ foo: 1, BAR: 2 }, 'to have a key matching', /^[a-z]+$/); // passes
+ * expect({ foo: 1, BAR: 2 }, 'to have a prop matching', /^[a-z]+$/); // alias
+ * expect({ foo: 1, BAR: 2 }, 'to have a field matching', /^[a-z]+$/); // alias
+ * expect({ FOO: 1, BAR: 2 }, 'to have a key matching', /^[a-z]+$/); // fails
+ * expect({ foo: 1 }, 'to have key matching', /foo/); // passes
+ * ```
+ *
+ * @function
+ * @group Collection Assertions
+ * @bupkisAnchor object-to-have-a-key-matching-regexp
+ * @bupkisAssertionCategory object
+ */
+export declare const objectHasKeyMatchingAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.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"], z.ZodCustom<RegExp, RegExp>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), pattern: RegExp) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").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"]>, z.ZodCustom<RegExp, RegExp>]>;
+//# sourceMappingURL=sync-collection.d.ts.map