bupkis 0.18.1 → 0.18.2

package/dist/assertion/impl/sync-collection.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"sync-collection.js","sourceRoot":"","sources":["../../../src/assertion/impl/sync-collection.ts"],"names":[],"mappings":"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"}

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

@@ -1,607 +0,0 @@
-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;
-    actual?: undefined;
-    expected?: undefined;
-} | {
-    actual: unknown;
-    expected: string;
-    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;
-    actual?: undefined;
-    expected?: undefined;
-} | {
-    actual: unknown;
-    expected: string;
-    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>]>;
-//# sourceMappingURL=sync-collection.d.ts.map

package/dist/assertion/impl/sync-collection.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sync-collection.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/sync-collection.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyBxB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;mRAuBhC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB,2YAM5B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,qVAK7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;+OAsBhC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,gVAS5B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,+RAK7B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB;;iKASlC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,2BAA2B;;4NAsBvC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,iXAY9B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB,0PAGlC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AAGH,eAAO,MAAM,mBAAmB,6oCA8B/B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,kBAAkB;;;;gdA0B9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,uBAAuB,89BAWnC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB;;;;+LAY/B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,uXAKhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,yYAG9B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,6YAGhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,mYAGpC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,uYAGhC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,yBAAyB,gjBAUrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gCAAgC,8jBAU5C,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,8BAA8B,0jBAU1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uCAAuC,8kBAUnD,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe;;;;oKAW3B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB;;;;+NAkB7B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;saAsC7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;8MAyBhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kCAAkC;;;;8OAe9C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,+BAA+B;;;;2OAe3C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,8BAA8B;;uQAc1C,CAAC"}