bupkis 0.10.6 → 0.11.0

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

@@ -19,11 +19,15 @@ import { z } from 'zod/v4';
  * @bupkisAnchor map-to-contain-any
  * @bupkisAssertionCategory collections
  */
-export declare const mapContainsAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: Map<unknown, unknown> | WeakMap<WeakKey, unknown>, key: unknown) => true | {
+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?: never;
+    expected?: never;
+} | {
     actual: unknown;
     expected: string;
     message: string;
-}, readonly [z.ZodUnion<[z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>;
+} | 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.
  *
@@ -42,11 +46,7 @@ export declare const mapContainsAssertion: import("../assertion-types.js").Asser
  * @bupkisAnchor map-to-have-size-nonnegative-integer
  * @bupkisAssertionCategory collections
  */
-export declare const mapSizeAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodMap<z.ZodUnknown, z.ZodUnknown>, "to have size", z.ZodInt], (subject: Map<unknown, unknown>, expectedSize: number) => true | {
-    actual: number;
-    expected: number;
-    message: string;
-}, readonly [z.ZodMap<z.ZodUnknown, z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>;
+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.
  *
@@ -61,7 +61,7 @@ export declare const mapSizeAssertion: import("../assertion-types.js").Assertion
  * @bupkisAnchor map-to-be-empty
  * @bupkisAssertionCategory collections
  */
-export declare const emptyMapAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodMap<z.ZodUnknown, z.ZodUnknown>, "to be empty"], (subject: Map<unknown, unknown>) => boolean, readonly [z.ZodMap<z.ZodUnknown, z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
+export declare const emptyMapAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"]>, 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.
@@ -82,11 +82,15 @@ export declare const emptyMapAssertion: import("../assertion-types.js").Assertio
  * @bupkisAnchor set-to-contain-any
  * @bupkisAssertionCategory collections
  */
-export declare const setContainsAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodSet<z.ZodUnknown>, z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => true | {
+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?: never;
+    expected?: never;
+} | {
     actual: unknown;
     expected: string;
     message: string;
-}, readonly [z.ZodUnion<[z.ZodSet<z.ZodUnknown>, z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>;
+} | 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.
  *
@@ -102,11 +106,7 @@ export declare const setContainsAssertion: import("../assertion-types.js").Asser
  * @bupkisAnchor set-to-have-size-nonnegative-integer
  * @bupkisAssertionCategory collections
  */
-export declare const setSizeAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodUnknown>, "to have size", z.ZodInt], (subject: Set<unknown>, expectedSize: number) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>;
+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.
  *
@@ -121,11 +121,7 @@ export declare const setSizeAssertion: import("../assertion-types.js").Assertion
  * @bupkisAnchor set-to-be-empty
  * @bupkisAssertionCategory collections
  */
-export declare const emptySetAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodUnknown>, "to be empty"], (subject: Set<unknown>) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
+export declare const emptySetAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"]>, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
 /**
  * Asserts that an array contains a specific value.
  *
@@ -140,18 +136,16 @@ export declare const emptySetAssertion: import("../assertion-types.js").Assertio
  * @bupkisAnchor array-to-contain-any
  * @bupkisAssertionCategory collections
  */
-export declare const arrayContainsAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, readonly ["to contain", "to include"], z.ZodAny], (subject: any[], value: any) => true | {
-    actual: any[];
-    expected: string;
+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;
-}, readonly [z.ZodArray<z.ZodAny>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>;
+} | undefined, readonly [z.ZodArray<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>;
 /**
  * Asserts that an array has a specific size.
  *
  * @example
  *
  * ```ts
- * expect([1, 2, 3], 'to have size', 3); // passes
+ * expect([1, 2, 3], 'to have length', 3); // passes
  * expect([1, 2, 3], 'to have size', 2); // fails
  * ```
  *
@@ -159,26 +153,7 @@ export declare const arrayContainsAssertion: import("../assertion-types.js").Ass
  * @bupkisAnchor array-to-have-size-nonnegative-integer
  * @bupkisAssertionCategory collections
  */
-export declare const arraySizeAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to have size", z.ZodInt], (subject: any[], expectedSize: number) => true | {
-    actual: number;
-    expected: number;
-    message: string;
-}, readonly [z.ZodArray<z.ZodAny>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>;
-/**
- * Asserts that an array has a specific length.
- *
- * @example
- *
- * ```ts
- * expect([1, 2, 3], 'to have length', 3); // passes
- * expect([1, 2, 3], 'to have length', 2); // fails
- * ```
- *
- * @group Collection Assertions
- * @bupkisAnchor array-to-have-length-nonnegative-integer
- * @bupkisAssertionCategory collections
- */
-export declare const arrayLengthAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, "to have length", z.ZodInt], (_: unknown[], expectedLength: number) => z.ZodArray<z.ZodUnknown>, readonly [z.ZodArray<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have length">, z.ZodInt]>;
+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.
  *
@@ -193,11 +168,7 @@ export declare const arrayLengthAssertion: import("../assertion-types.js").Asser
  * @bupkisAnchor array-not-to-be-empty
  * @bupkisAssertionCategory collections
  */
-export declare const nonEmptyArrayAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"], (subject: unknown[]) => {
-    actual: string;
-    expected: string;
-    message: string;
-} | undefined, readonly [z.ZodArray<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>;
+export declare const nonEmptyArrayAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"]>, readonly [z.ZodArray<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>;
 /**
  * Asserts that an object has specific keys/properties.
  *
@@ -212,11 +183,7 @@ export declare const nonEmptyArrayAssertion: import("../assertion-types.js").Ass
  * @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"], z.ZodArray<z.ZodString>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: string[]) => {
-    actual: string;
-    expected: 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 keys", "to have properties", "to have props"]>, z.ZodArray<z.ZodString>]>;
+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
@@ -247,11 +214,11 @@ export declare const objectKeysAssertion: import("../assertion-types.js").Assert
  * @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"], z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keypath: string) => {
+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"]>, z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>]>;
+} | 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
@@ -325,7 +292,7 @@ export declare const objectSizeAssertion: import("../assertion-types.js").Assert
  * @bupkisAnchor set-to-equal-set
  * @bupkisAssertionCategory collections
  */
-export declare const setEqualityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodUnknown>, "to equal", z.ZodSet<z.ZodUnknown>], (actual: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to equal">, z.ZodSet<z.ZodUnknown>]>;
+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.
  *
@@ -340,7 +307,7 @@ export declare const setEqualityAssertion: import("../assertion-types.js").Asser
  * @bupkisAnchor set-to-be-a-subset-of-set
  * @bupkisAssertionCategory collections
  */
-export declare const setSubsetAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodUnknown>, "to be a subset of", z.ZodSet<z.ZodUnknown>], (subset: Set<unknown>, superset: Set<unknown>) => boolean, readonly [z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be a subset of">, z.ZodSet<z.ZodUnknown>]>;
+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.
  *
@@ -355,7 +322,7 @@ export declare const setSubsetAssertion: import("../assertion-types.js").Asserti
  * @bupkisAnchor set-to-be-a-superset-of-set
  * @bupkisAssertionCategory collections
  */
-export declare const setSupersetAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodUnknown>, "to be a superset of", z.ZodSet<z.ZodUnknown>], (superset: Set<unknown>, subset: Set<unknown>) => boolean, readonly [z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be a superset of">, z.ZodSet<z.ZodUnknown>]>;
+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).
  *
@@ -370,7 +337,7 @@ export declare const setSupersetAssertion: import("../assertion-types.js").Asser
  * @bupkisAnchor set-to-have-intersection-with-set-satisfying-any
  * @bupkisAssertionCategory collections
  */
-export declare const setIntersectionAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodUnknown>, "to intersect with", z.ZodSet<z.ZodUnknown>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to intersect with">, z.ZodSet<z.ZodUnknown>]>;
+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).
  *
@@ -385,7 +352,7 @@ export declare const setIntersectionAssertion: import("../assertion-types.js").A
  * @bupkisAnchor set-to-be-disjoint-from-set
  * @bupkisAssertionCategory collections
  */
-export declare const setDisjointAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodUnknown>, "to be disjoint from", z.ZodSet<z.ZodUnknown>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be disjoint from">, z.ZodSet<z.ZodUnknown>]>;
+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.
  *
@@ -405,7 +372,7 @@ export declare const setDisjointAssertion: import("../assertion-types.js").Asser
  * @bupkisAnchor set-union-with-set-to-equal-set
  * @bupkisAssertionCategory collections
  */
-export declare const setUnionEqualityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodUnknown>, "to have union", z.ZodSet<z.ZodUnknown>, "equal to", z.ZodSet<z.ZodUnknown>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have union">, z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, z.ZodSet<z.ZodUnknown>]>;
+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.
  *
@@ -425,7 +392,7 @@ export declare const setUnionEqualityAssertion: import("../assertion-types.js").
  * @bupkisAnchor set-intersection-with-set-to-equal-set
  * @bupkisAssertionCategory collections
  */
-export declare const setIntersectionEqualityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodUnknown>, "to have intersection", z.ZodSet<z.ZodUnknown>, "equal to", z.ZodSet<z.ZodUnknown>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have intersection">, z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, z.ZodSet<z.ZodUnknown>]>;
+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.
  *
@@ -445,7 +412,7 @@ export declare const setIntersectionEqualityAssertion: import("../assertion-type
  * @bupkisAnchor set-difference-with-set-to-equal-set
  * @bupkisAssertionCategory collections
  */
-export declare const setDifferenceEqualityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodUnknown>, "to have difference", z.ZodSet<z.ZodUnknown>, "equal to", z.ZodSet<z.ZodUnknown>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have difference">, z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, z.ZodSet<z.ZodUnknown>]>;
+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.
  *
@@ -465,7 +432,7 @@ export declare const setDifferenceEqualityAssertion: import("../assertion-types.
  * @bupkisAnchor set-symmetric-difference-with-set-to-equal-set
  * @bupkisAssertionCategory collections
  */
-export declare const setSymmetricDifferenceEqualityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodUnknown>, "to have symmetric difference", z.ZodSet<z.ZodUnknown>, "equal to", z.ZodSet<z.ZodUnknown>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have symmetric difference">, z.ZodSet<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, z.ZodSet<z.ZodUnknown>]>;
+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.
  *
@@ -481,11 +448,11 @@ export declare const setSymmetricDifferenceEqualityAssertion: import("../asserti
  * @bupkisAnchor map-to-have-key-any
  * @bupkisAssertionCategory collections
  */
-export declare const mapKeyAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodMap<z.ZodUnknown, z.ZodUnknown>, "to have key", z.ZodUnknown], (map: Map<unknown, unknown>, key: unknown) => true | {
+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;
+    expected: unknown[];
     message: string;
-}, readonly [z.ZodMap<z.ZodUnknown, z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have key">, z.ZodUnknown]>;
+} | 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.
  *
@@ -501,11 +468,11 @@ export declare const mapKeyAssertion: import("../assertion-types.js").AssertionF
  * @bupkisAnchor map-to-have-value-any
  * @bupkisAssertionCategory collections
  */
-export declare const mapValueAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodMap<z.ZodUnknown, z.ZodUnknown>, "to have value", z.ZodUnknown], (map: Map<unknown, unknown>, value: unknown) => true | {
+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;
-}, readonly [z.ZodMap<z.ZodUnknown, z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have value">, z.ZodUnknown]>;
+} | 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.
  *
@@ -521,15 +488,15 @@ export declare const mapValueAssertion: import("../assertion-types.js").Assertio
  * @bupkisAnchor map-to-have-entry-any-any
  * @bupkisAssertionCategory collections
  */
-export declare const mapEntryAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, "to have entry", z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>], (map: Map<unknown, unknown> | WeakMap<WeakKey, unknown>, [key, value]: [unknown, unknown]) => true | {
-    actual: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-    expected: string;
+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?: never;
+    expected?: never;
 } | {
     actual: unknown[] | undefined;
     expected: unknown[];
     message: string;
-}, readonly [z.ZodUnion<[z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have entry">, z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>]>;
+} | 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).
  *
@@ -551,19 +518,19 @@ export declare const mapEntryAssertion: import("../assertion-types.js").Assertio
  * @bupkisAnchor map-to-equal-map
  * @bupkisAssertionCategory collections
  */
-export declare const mapEqualityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodMap<z.ZodUnknown, z.ZodUnknown>, "to equal", z.ZodMap<z.ZodUnknown, z.ZodUnknown>], (mapA: Map<unknown, unknown>, mapB: Map<unknown, unknown>) => true | {
+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;
 } | {
-    actual: string;
-    expected: string;
     message: string;
+    actual?: never;
+    expected?: never;
 } | {
     actual: unknown[];
     expected: unknown[];
     message: string;
-}, readonly [z.ZodMap<z.ZodUnknown, z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to equal">, z.ZodMap<z.ZodUnknown, z.ZodUnknown>]>;
+} | 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.
  *
@@ -578,11 +545,11 @@ export declare const mapEqualityAssertion: import("../assertion-types.js").Asser
  * @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.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodSet<z.ZodUnknown>]>, "to have size greater than", z.ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, minSize: number) => true | {
+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: string;
+    expected: number;
     message: string;
-}, readonly [z.ZodUnion<readonly [z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodSet<z.ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size greater than">, z.ZodInt]>;
+} | 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.
  *
@@ -597,11 +564,11 @@ export declare const collectionSizeGreaterThanAssertion: import("../assertion-ty
  * @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.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodSet<z.ZodUnknown>]>, "to have size less than", z.ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, maxSize: number) => true | {
+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: string;
+    expected: number;
     message: string;
-}, readonly [z.ZodUnion<readonly [z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodSet<z.ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size less than">, z.ZodInt]>;
+} | 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.
  *
@@ -616,9 +583,7 @@ export declare const collectionSizeLessThanAssertion: import("../assertion-types
  * @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.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodSet<z.ZodUnknown>]>, "to have size between", z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>], (collection: Map<unknown, unknown> | Set<unknown>, [min, max]: [number, number]) => true | {
-    actual: number;
-    expected: string;
+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.ZodNumber, z.ZodNumber], null>], (collection: Map<unknown, unknown> | Set<unknown>, [min, max]: [number, number]) => {
     message: string;
-}, readonly [z.ZodUnion<readonly [z.ZodMap<z.ZodUnknown, z.ZodUnknown>, z.ZodSet<z.ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size between">, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
+} | 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.ZodNumber, z.ZodNumber], null>]>;
 //# sourceMappingURL=sync-collection.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sync-collection.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync-collection.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAc3B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB;;;;kPA8BhC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB;;;;gIAY5B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,uRAG7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB;;;;kNA6BhC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB;;;;8HAW5B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB;;;;mHAW7B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB;;;;6IAYlC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB;;;;gHAY9B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,gTAIhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB;;;;yHAWlC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AAGH,eAAO,MAAM,mBAAmB;;;;8SAgB/B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,kBAAkB;;;;wVAgB9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,uBAAuB,89BAWnC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB;;;;;;sIAY/B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,mTAKhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,qUAG9B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,yUAGhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,+TAGpC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,mUAGhC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,yBAAyB,0cAgBrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gCAAgC,wdAgB5C,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,8BAA8B,odAgB1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uCAAuC,weAgBnD,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe;;;;mIAY3B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB;;;;qIAc7B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;wPAiC7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;wJAgChC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kCAAkC;;;;4LAgB9C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,+BAA+B;;;;yLAgB3C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,8BAA8B;;;;2NAiB1C,CAAC"}
+{"version":3,"file":"sync-collection.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync-collection.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAkB3B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;mRAuBhC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB,2YAM5B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,gaAK7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;+OAsBhC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,gVAS5B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,0WAG7B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB;;iKASlC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,iXAe9B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB,yUAGlC,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;;;;;;sIAY/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;;6QAc1C,CAAC"}