bupkis 0.10.4 → 0.11.0

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

@@ -1 +1 @@
-{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAmIH,eAAO,MAAM,kBAAkB,ijUAgBrB,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;+tCAOzB,CAAC;AAEX;;;;GAIG;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;wnNAuCtB,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2JA8B3B,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wUA+B3B,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qwWAMjB,CAAC;AAIX,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAkIH;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+WAgBrB,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;+tCAOzB,CAAC;AAEX;;;;GAIG;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;wnNAuCtB,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2JA8B3B,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sVA8B3B,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+WAMjB,CAAC;AAIX,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC"}

package/dist/commonjs/assertion/impl/sync.js

@@ -34,6 +34,11 @@ const sync_collection_js_1 = require("./sync-collection.js");
 const sync_date_js_1 = require("./sync-date.js");
 const sync_esoteric_js_1 = require("./sync-esoteric.js");
 const sync_parametric_js_1 = require("./sync-parametric.js");
+/**
+ * Tuple of all built-in date-related synchronous assertions.
+ *
+ * @group Assertion Collections
+ */
 exports.SyncDateAssertions = [
     sync_date_js_1.afterAssertion,
     sync_date_js_1.atLeastAgoAssertion,
@@ -157,7 +162,6 @@ exports.SyncCollectionAssertions = [
     sync_collection_js_1.emptySetAssertion,
     sync_collection_js_1.arrayContainsAssertion,
     sync_collection_js_1.arraySizeAssertion,
-    sync_collection_js_1.arrayLengthAssertion,
     sync_collection_js_1.nonEmptyArrayAssertion,
     sync_collection_js_1.objectKeysAssertion,
     sync_collection_js_1.objectSizeAssertion,

package/dist/commonjs/assertion/impl/sync.js.map

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

package/dist/commonjs/bootstrap.d.ts

@@ -15,93 +15,73 @@ declare const
  * @function
  * @group Core API
  */
-expect: Expect<readonly [import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<[import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, readonly ["to contain", "to include"], import("zod").ZodUnknown], (subject: Map<unknown, unknown> | WeakMap<WeakKey, unknown>, key: unknown) => true | {
-    actual: unknown;
-    expected: string;
-    message: string;
-}, readonly [import("zod").ZodUnion<[import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, "to have size", import("zod").ZodInt], (subject: Map<unknown, unknown>, expectedSize: number) => true | {
-    actual: number;
-    expected: number;
+expect: Expect<readonly [import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, readonly ["to contain", "to include"], import("zod").ZodUnknown], (subject: Map<unknown, unknown> | WeakMap<WeakKey, unknown>, key: unknown) => {
     message: string;
-}, readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, "to be empty"], (subject: Map<unknown, unknown>) => boolean, readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<[import("zod").ZodSet<import("zod").ZodUnknown>, import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], import("zod").ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => true | {
+    actual?: never;
+    expected?: never;
+} | {
     actual: unknown;
     expected: string;
     message: string;
-}, readonly [import("zod").ZodUnion<[import("zod").ZodSet<import("zod").ZodUnknown>, import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodSet<import("zod").ZodUnknown>, "to have size", import("zod").ZodInt], (subject: Set<unknown>, expectedSize: number) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodSet<import("zod").ZodUnknown>, "to be empty"], (subject: Set<unknown>) => {
-    actual: number;
-    expected: number;
+} | undefined, readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", import("zod").ZodInt], (_subject: Map<unknown, unknown>, expectedSize: number) => import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodInt]>, import("./types.js").AssertionSchemaSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"]>, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], import("zod").ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => {
     message: string;
-} | undefined, readonly [import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodAny>, readonly ["to contain", "to include"], import("zod").ZodAny], (subject: any[], value: any) => true | {
-    actual: any[];
-    expected: string;
-    message: string;
-}, readonly [import("zod").ZodArray<import("zod").ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodAny>, "to have size", import("zod").ZodInt], (subject: any[], expectedSize: number) => true | {
-    actual: number;
-    expected: number;
-    message: string;
-}, readonly [import("zod").ZodArray<import("zod").ZodAny>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, "to have length", import("zod").ZodInt], (_: unknown[], expectedLength: number) => import("zod").ZodArray<import("zod").ZodUnknown>, readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have length">, import("zod").ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, "to be non-empty"], (subject: unknown[]) => {
-    actual: string;
+    actual?: never;
+    expected?: never;
+} | {
+    actual: unknown;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys", "to have properties", "to have props"], import("zod").ZodArray<import("zod").ZodString>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: string[]) => {
-    actual: string;
-    expected: string;
+} | undefined, readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have size", import("zod").ZodInt], (_subject: Set<unknown>, expectedSize: number) => import("zod").ZodSet<import("zod").ZodUnknown>, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodInt]>, import("./types.js").AssertionSchemaSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"]>, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, readonly ["to contain", "to include"], import("zod").ZodUnknown], (subject: unknown[], value: unknown) => {
     message: string;
-} | undefined, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props"]>, import("zod").ZodArray<import("zod").ZodString>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodObject<{}, import("zod/v4/core").$loose>, "to have size", import("zod").ZodInt], (subject: {
+} | undefined, readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, readonly ["to have length", "to have size"], import("zod").ZodInt], (_subject: unknown[], expectedSize: number) => import("zod").ZodArray<import("zod").ZodUnknown>, readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>, import("zod").ZodInt]>, import("./types.js").AssertionSchemaSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, "to be non-empty"], import("./types.js").AssertionImplSchemaSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, "to be non-empty"]>, readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").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"], import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>>], (_subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: (string | number | symbol)[]) => import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./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"]>, import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodObject<{}, import("zod/v4/core").$loose>, "to have size", import("zod").ZodInt], (subject: {
     [x: string]: unknown;
 }, expectedSize: number) => {
     actual: number;
     expected: number;
     message: string;
-} | undefined, readonly [import("zod").ZodObject<{}, import("zod/v4/core").$loose>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").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"], import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>], (_: Record<PropertyKey, unknown> | ((...args: any[]) => any), key: string | number | symbol) => import("zod").ZodPipe<import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("zod").ZodTransform<{}, Record<PropertyKey, unknown> | ((...args: any[]) => any)>>, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have exact key", "to have exact property", "to have exact prop"]>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have key", "to have property", "to have prop"], import("zod").ZodType<string, unknown, import("zod/v4/core").$ZodTypeInternals<string, unknown>>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keypath: string) => {
+} | undefined, readonly [import("zod").ZodObject<{}, import("zod/v4/core").$loose>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").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"], import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>], (_: Record<PropertyKey, unknown> | ((...args: any[]) => any), key: string | number | symbol) => import("zod").ZodPipe<import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("zod").ZodTransform<{}, Record<PropertyKey, unknown> | ((...args: any[]) => any)>>, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have exact key", "to have exact property", "to have exact prop"]>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").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"], import("zod").ZodType<string, unknown, import("zod/v4/core").$ZodTypeInternals<string, unknown>>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keypath: string) => {
     actual: string;
     expect: string;
     message: string;
-} | undefined, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have key", "to have property", "to have prop"]>, import("zod").ZodType<string, unknown, import("zod/v4/core").$ZodTypeInternals<string, unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodSet<import("zod").ZodUnknown>, "to equal", import("zod").ZodSet<import("zod").ZodUnknown>], (actual: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to equal">, import("zod").ZodSet<import("zod").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodSet<import("zod").ZodUnknown>, "to be a subset of", import("zod").ZodSet<import("zod").ZodUnknown>], (subset: Set<unknown>, superset: Set<unknown>) => boolean, readonly [import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be a subset of">, import("zod").ZodSet<import("zod").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodSet<import("zod").ZodUnknown>, "to be a superset of", import("zod").ZodSet<import("zod").ZodUnknown>], (superset: Set<unknown>, subset: Set<unknown>) => boolean, readonly [import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be a superset of">, import("zod").ZodSet<import("zod").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodSet<import("zod").ZodUnknown>, "to intersect with", import("zod").ZodSet<import("zod").ZodUnknown>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to intersect with">, import("zod").ZodSet<import("zod").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodSet<import("zod").ZodUnknown>, "to be disjoint from", import("zod").ZodSet<import("zod").ZodUnknown>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be disjoint from">, import("zod").ZodSet<import("zod").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodSet<import("zod").ZodUnknown>, "to have union", import("zod").ZodSet<import("zod").ZodUnknown>, "equal to", import("zod").ZodSet<import("zod").ZodUnknown>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have union">, import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodSet<import("zod").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodSet<import("zod").ZodUnknown>, "to have intersection", import("zod").ZodSet<import("zod").ZodUnknown>, "equal to", import("zod").ZodSet<import("zod").ZodUnknown>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have intersection">, import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodSet<import("zod").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodSet<import("zod").ZodUnknown>, "to have difference", import("zod").ZodSet<import("zod").ZodUnknown>, "equal to", import("zod").ZodSet<import("zod").ZodUnknown>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have difference">, import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodSet<import("zod").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodSet<import("zod").ZodUnknown>, "to have symmetric difference", import("zod").ZodSet<import("zod").ZodUnknown>, "equal to", import("zod").ZodSet<import("zod").ZodUnknown>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have symmetric difference">, import("zod").ZodSet<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodSet<import("zod").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, "to have key", import("zod").ZodUnknown], (map: Map<unknown, unknown>, key: unknown) => true | {
+} | undefined, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./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"]>, import("zod").ZodType<string, unknown, import("zod/v4/core").$ZodTypeInternals<string, unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to equal", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (actual: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to equal">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be a subset of", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (subset: Set<unknown>, superset: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be a subset of">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be a superset of", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (superset: Set<unknown>, subset: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be a superset of">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to intersect with", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to intersect with">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be disjoint from", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be disjoint from">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have union", import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "equal to", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have union">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have intersection", import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "equal to", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have intersection">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have difference", import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "equal to", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have difference">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have symmetric difference", import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "equal to", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have symmetric difference">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have key", import("zod").ZodUnknown], (map: Map<unknown, unknown>, key: unknown) => {
     actual: unknown[];
-    expected: unknown;
+    expected: unknown[];
     message: string;
-}, readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have key">, import("zod").ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, "to have value", import("zod").ZodUnknown], (map: Map<unknown, unknown>, value: unknown) => true | {
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have key">, import("zod").ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have value", "to contain value", "to include value"], import("zod").ZodUnknown], (map: Map<unknown, unknown>, value: unknown) => {
     actual: unknown[];
     expected: unknown;
     message: string;
-}, readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have value">, import("zod").ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<[import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, "to have entry", import("zod").ZodTuple<[import("zod").ZodUnknown, import("zod").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;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have value", "to contain value", "to include value"]>, import("zod").ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").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"], import("zod").ZodTuple<[import("zod").ZodUnknown, import("zod").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 [import("zod").ZodUnion<[import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("./types.js").PhraseLiteralSlot<"to have entry">, import("zod").ZodTuple<[import("zod").ZodUnknown, import("zod").ZodUnknown], null>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, "to equal", import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>], (mapA: Map<unknown, unknown>, mapB: Map<unknown, unknown>) => true | {
+} | undefined, readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("./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"]>, import("zod").ZodTuple<[import("zod").ZodUnknown, import("zod").ZodUnknown], null>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to equal", import("zod").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 [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to equal">, import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("zod").ZodSet<import("zod").ZodUnknown>]>, "to have size greater than", import("zod").ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, minSize: number) => true | {
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to equal">, import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size greater than", import("zod").ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, minSize: number) => {
     actual: number;
-    expected: string;
+    expected: number;
     message: string;
-}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("zod").ZodSet<import("zod").ZodUnknown>]>, import("./types.js").PhraseLiteralSlot<"to have size greater than">, import("zod").ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("zod").ZodSet<import("zod").ZodUnknown>]>, "to have size less than", import("zod").ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, maxSize: number) => true | {
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to have size greater than">, import("zod").ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size less than", import("zod").ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, maxSize: number) => {
     actual: number;
-    expected: string;
+    expected: number;
     message: string;
-}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("zod").ZodSet<import("zod").ZodUnknown>]>, import("./types.js").PhraseLiteralSlot<"to have size less than">, import("zod").ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("zod").ZodSet<import("zod").ZodUnknown>]>, "to have size between", import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>], (collection: Map<unknown, unknown> | Set<unknown>, [min, max]: [number, number]) => true | {
-    actual: number;
-    expected: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to have size less than">, import("zod").ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size between", import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>], (collection: Map<unknown, unknown> | Set<unknown>, [min, max]: [number, number]) => {
     message: string;
-}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, import("zod").ZodSet<import("zod").ZodUnknown>]>, import("./types.js").PhraseLiteralSlot<"to have size between">, import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>]>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be an array", "to be array"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be an array", "to be array"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be an async function"], import("./types.js").AssertionImplSchemaSync<readonly ["to be an async function"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a date", "to be a Date"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be defined"], import("./types.js").AssertionImplSchemaSync<readonly ["to be defined"]>, never>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("zod").ZodTuple<[import("zod").ZodUnknown], import("zod").ZodUnknown>, import("zod").ZodObject<{
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to have size between">, import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>]>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be an array", "to be array"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be an array", "to be array"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be an async function"], import("./types.js").AssertionImplSchemaSync<readonly ["to be an async function"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a date", "to be a Date"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be defined"], import("./types.js").AssertionImplSchemaSync<readonly ["to be defined"]>, never>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("zod").ZodTuple<[import("zod").ZodUnknown], import("zod").ZodUnknown>, import("zod").ZodObject<{
     length: import("zod").ZodNumber;
 }, import("zod/v4/core").$loose>]>, "to be empty"], (subject: unknown[] | [unknown, ...unknown[]] | {
     [x: string]: unknown;
@@ -114,7 +94,7 @@ expect: Expect<readonly [import("./types.js").AssertionFunctionSync<readonly [im
     length: import("zod").ZodNumber;
 }, import("zod/v4/core").$loose>]>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionSchemaSync<readonly [import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodUnknown>, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodUnknown>, "to be empty"]>, readonly [import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionSchemaSync<readonly [import("zod").ZodString, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [import("zod").ZodString, "to be empty"]>, readonly [import("zod").ZodString, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be false"], import("./types.js").AssertionImplSchemaSync<readonly ["to be false"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be falsy"], import("./types.js").AssertionImplSchemaSync<readonly ["to be falsy"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a function"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a function"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be infinite"], import("./types.js").AssertionImplSchemaSync<readonly ["to be infinite"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be NaN"], import("./types.js").AssertionImplSchemaSync<readonly ["to be NaN"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be -Infinity"], import("./types.js").AssertionImplSchemaSync<readonly ["to be -Infinity"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [import("zod").ZodString, "to be non-empty"], import("./types.js").AssertionImplSchemaSync<readonly [import("zod").ZodString, "to be non-empty"]>, readonly [import("zod").ZodString, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionSchemaSync<readonly ["to be null"], import("./types.js").AssertionImplSchemaSync<readonly ["to be null"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a number", "to be finite"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a number", "to be finite"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be an object"], import("./types.js").AssertionImplSchemaSync<readonly ["to be an object"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be Infinity"], import("./types.js").AssertionImplSchemaSync<readonly ["to be Infinity"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a primitive"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a primitive"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a Set"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a Set"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a string"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a string"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be true"], import("./types.js").AssertionImplSchemaSync<readonly ["to be true"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be undefined"], import("./types.js").AssertionImplSchemaSync<readonly ["to be undefined"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a WeakMap"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a WeakMap"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a WeakSet"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a WeakSet"]>, never>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a", "to be an"], import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (_: unknown, ctor: import("./types.js").Constructor) => import("zod").ZodCustom<any, any>, readonly [import("zod").ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be an instance of", "to be a", "to be an"]>, import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodAny, readonly ["to be a", "to be an", "to have type"], import("zod").ZodEnum<{
     [x: string]: string;
-}>], (_: any, type: string) => import("zod").ZodString | import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | import("zod").ZodNumber | import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | import("zod").ZodArray<import("zod").ZodAny> | import("zod").ZodSymbol | import("zod").ZodBigInt | import("zod").ZodBoolean | import("zod").ZodDate | import("zod").ZodCustom<Error, Error> | import("zod").ZodNull | import("zod").ZodUndefined | import("zod").ZodCustom<RegExp, RegExp> | import("zod").ZodFunction<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut> | import("zod").ZodObject<{}, import("zod/v4/core").$loose> | import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | import("zod").ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>, readonly [import("zod").ZodAny, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, import("zod").ZodEnum<{
+}>], (_: any, type: string) => import("zod").ZodString | import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | import("zod").ZodNumber | import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | import("zod").ZodSymbol | import("zod").ZodArray<import("zod").ZodAny> | import("zod").ZodBigInt | import("zod").ZodBoolean | import("zod").ZodDate | import("zod").ZodCustom<Error, Error> | import("zod").ZodNull | import("zod").ZodUndefined | import("zod").ZodCustom<RegExp, RegExp> | import("zod").ZodFunction<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut> | import("zod").ZodObject<{}, import("zod/v4/core").$loose> | import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | import("zod").ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>, readonly [import("zod").ZodAny, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, import("zod").ZodEnum<{
     [x: string]: string;
 }>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, "to be greater than", import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("./types.js").PhraseLiteralSlot<"to be greater than">, import("zod").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be less than", "to be lt"], import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be less than", "to be lt"]>, import("zod").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be greater than or equal to", "to be at least", "to be gte"], import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be greater than or equal to", "to be at least", "to be gte"]>, import("zod").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be less than or equal to", "to be at most", "to be lte"], import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be less than or equal to", "to be at most", "to be lte"]>, import("zod").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be within", "to be between"], import("zod").ZodNumber, import("zod").ZodNumber], (subject: number, min: number, max: number) => {
     actual: number;
@@ -150,7 +130,7 @@ expect: Expect<readonly [import("./types.js").AssertionFunctionSync<readonly [im
     message: string;
 } | undefined, readonly [import("zod").ZodString, import("./types.js").PhraseLiteralSlot<"to end with">, import("zod").ZodString]>, import("./types.js").AssertionFunctionSync<readonly ["to be one of", import("zod").ZodArray<import("zod").ZodAny>], (subject: unknown, values: any[]) => {
     actual: unknown;
-    expected: string;
+    expected: any[];
     message: string;
 } | undefined, readonly [import("zod").ZodUnknown, import("./types.js").PhraseLiteralSlot<"to be one of">, import("zod").ZodArray<import("zod").ZodAny>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", import("zod").ZodInt], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
     actual: number;
@@ -185,16 +165,12 @@ expect: Expect<readonly [import("./types.js").AssertionFunctionSync<readonly [im
     expected: string;
     message: string;
 } | undefined, readonly [import("zod").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw", "to throw error satisfying"], import("zod").ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: any) => {
-    actual: unknown;
-    expected: string;
     message: string;
     schema?: never;
     subject?: never;
 } | {
     schema: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
     subject: {} | null;
-    actual?: never;
-    expected?: never;
     message?: never;
 }, readonly [import("zod").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw", "to throw error satisfying"]>, import("zod").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, "satisfying", import("zod").ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor, param: any) => {
     actual: unknown;
@@ -229,7 +205,123 @@ expect: Expect<readonly [import("./types.js").AssertionFunctionSync<readonly [im
     actual: boolean;
     expected: boolean;
     message: string;
-} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("./types.js").PhraseLiteralSlot<"to be an enumerable property of">, import("zod").ZodNonOptional<import("zod").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodNonOptional<import("zod").ZodUnknown>, "to have enumerable property", import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => import("zod").ZodCustom<unknown, unknown>, readonly [import("zod").ZodNonOptional<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have enumerable property">, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>]>, import("./types.js").AssertionSchemaSync<readonly ["to be sealed"], import("./types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be extensible"], import("./types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be after", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>], (subject: string | number | Date, other: string | number | Date) => import("./types.js").AssertionFailure | import("./types.js").AssertionParseRequest, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be after">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be at least", import("zod").ZodCustomStringFormat<"duration">, "ago"], (subject: string | number | Date, durationStr: string) => import("./types.js").AssertionFailure | import("./types.js").AssertionParseRequest, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be at least">, import("zod").ZodCustomStringFormat<"duration">, import("./types.js").PhraseLiteralSlot<"ago">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be at least", import("zod").ZodCustomStringFormat<"duration">, "from now"], (subject: string | number | Date, durationStr: string) => import("./types.js").AssertionFailure | import("./types.js").AssertionParseRequest, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be at least">, import("zod").ZodCustomStringFormat<"duration">, import("./types.js").PhraseLiteralSlot<"from now">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be before", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>], (subject: string | number | Date, other: string | number | Date) => import("./types.js").AssertionFailure | import("./types.js").AssertionParseRequest, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be before">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be between", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "and", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>], (subject: string | number | Date, start: string | number | Date, end: string | number | Date) => import("./types.js").AssertionFailure | import("./types.js").AssertionParseRequest, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be between">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"and">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to equal", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "within", import("zod").ZodCustomStringFormat<"duration">], (subject: string | number | Date, other: string | number | Date, toleranceStr: string) => import("./types.js").AssertionFailure | boolean, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to equal">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"within">, import("zod").ZodCustomStringFormat<"duration">]>, import("./types.js").AssertionFunctionSync<readonly ["to be in the future"], (subject: unknown) => import("./types.js").AssertionFailure | import("./types.js").AssertionParseRequest, never>, import("./types.js").AssertionFunctionSync<readonly ["to be in the past"], (subject: unknown) => import("./types.js").AssertionFailure | import("./types.js").AssertionParseRequest, never>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be the same date as", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>], (subject: string | number | Date, other: string | number | Date) => import("./types.js").AssertionFailure | boolean, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be the same date as">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>]>, import("./types.js").AssertionFunctionSync<readonly ["to be today"], (subject: unknown) => import("./types.js").AssertionFailure | boolean, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]]>, never>, import("./types.js").AssertionFunctionSync<readonly ["to be a weekday"], (subject: unknown) => import("./types.js").AssertionFailure | boolean, never>, import("./types.js").AssertionFunctionSync<readonly ["to be a weekend"], (subject: unknown) => import("./types.js").AssertionFailure | boolean, never>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be within", import("zod").ZodCustomStringFormat<"duration">, "ago"], (subject: string | number | Date, durationStr: string) => import("./types.js").AssertionFailure | import("./types.js").AssertionParseRequest, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be within">, import("zod").ZodCustomStringFormat<"duration">, import("./types.js").PhraseLiteralSlot<"ago">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be within", import("zod").ZodCustomStringFormat<"duration">, "from now"], (subject: string | number | Date, durationStr: string) => import("./types.js").AssertionFailure | import("./types.js").AssertionParseRequest, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be within">, import("zod").ZodCustomStringFormat<"duration">, import("./types.js").PhraseLiteralSlot<"from now">]>]>, 
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("./types.js").PhraseLiteralSlot<"to be an enumerable property of">, import("zod").ZodNonOptional<import("zod").ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodNonOptional<import("zod").ZodUnknown>, "to have enumerable property", import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => import("zod").ZodCustom<unknown, unknown>, readonly [import("zod").ZodNonOptional<import("zod").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have enumerable property">, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>]>, import("./types.js").AssertionSchemaSync<readonly ["to be sealed"], import("./types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be extensible"], import("./types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be after", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>], (subject: string | number | Date, other: string | number | Date) => {
+    message: string;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: never;
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be after">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be at least", import("zod").ZodCustomStringFormat<"duration">, "ago"], (subject: string | number | Date, durationStr: string) => {
+    message: string;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: never;
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be at least">, import("zod").ZodCustomStringFormat<"duration">, import("./types.js").PhraseLiteralSlot<"ago">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be at least", import("zod").ZodCustomStringFormat<"duration">, "from now"], (subject: string | number | Date, durationStr: string) => {
+    message: string;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: never;
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be at least">, import("zod").ZodCustomStringFormat<"duration">, import("./types.js").PhraseLiteralSlot<"from now">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be before", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>], (subject: string | number | Date, other: string | number | Date) => {
+    message: string;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: never;
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be before">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be between", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "and", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>], (subject: string | number | Date, start: string | number | Date, end: string | number | Date) => {
+    message: string;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: never;
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be between">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"and">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to equal", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "within", import("zod").ZodCustomStringFormat<"duration">], (subject: string | number | Date, other: string | number | Date, toleranceStr: string) => {
+    message: string;
+    actual?: never;
+    expected?: never;
+} | {
+    actual: {
+        difference: number;
+    };
+    expected: {
+        maxDifference: number;
+    };
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to equal">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"within">, import("zod").ZodCustomStringFormat<"duration">]>, import("./types.js").AssertionFunctionSync<readonly ["to be in the future"], (subject: unknown) => {
+    message: string;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: never;
+}, never>, import("./types.js").AssertionFunctionSync<readonly ["to be in the past"], (subject: unknown) => {
+    message: string;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: never;
+}, never>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be the same date as", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>], (subject: string | number | Date, other: string | number | Date) => {
+    message: string;
+    actual?: never;
+    expected?: never;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be the same date as">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>]>, import("./types.js").AssertionFunctionSync<readonly ["to be today"], (subject: unknown) => {
+    message: string;
+    actual?: never;
+    expected?: never;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]]>, never>, import("./types.js").AssertionFunctionSync<readonly ["to be a weekday"], (subject: unknown) => {
+    message: string;
+    actual?: never;
+    expected?: never;
+} | {
+    actual: "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | undefined;
+    expected: string;
+    message: string;
+} | undefined, never>, import("./types.js").AssertionFunctionSync<readonly ["to be a weekend"], (subject: unknown) => {
+    message: string;
+    actual?: never;
+    expected?: never;
+} | {
+    actual: "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | undefined;
+    expected: string;
+    message: string;
+} | undefined, never>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be within", import("zod").ZodCustomStringFormat<"duration">, "ago"], (subject: string | number | Date, durationStr: string) => {
+    message: string;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: never;
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be within">, import("zod").ZodCustomStringFormat<"duration">, import("./types.js").PhraseLiteralSlot<"ago">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, "to be within", import("zod").ZodCustomStringFormat<"duration">, "from now"], (subject: string | number | Date, durationStr: string) => {
+    message: string;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: never;
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodNumber]>, import("./types.js").PhraseLiteralSlot<"to be within">, import("zod").ZodCustomStringFormat<"duration">, import("./types.js").PhraseLiteralSlot<"from now">]>]>, 
 /**
  * The main asynchronous assertion function which can execute only built-in
  * assertions.
@@ -238,20 +330,12 @@ expect: Expect<readonly [import("./types.js").AssertionFunctionSync<readonly [im
  * @group Core API
  */
 expectAsync: ExpectAsync<readonly [import("./types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to resolve", "to fulfill"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
-    actual: string;
-    expected: string;
     message: string;
 } | undefined>, readonly [import("zod").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<{
-    actual: string;
-    expected: string;
     message: string;
 } | undefined>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to reject"], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
-    actual: string;
-    expected: string;
     message: string;
 } | undefined>, readonly [import("zod").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, "to reject"], (subject: PromiseLike<unknown>) => Promise<{
-    actual: string;
-    expected: string;
     message: string;
 } | undefined>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an"], import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => Promise<{
     actual: string;

package/dist/commonjs/bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAyB3D,QAAA;AACE;;;;;;GAMG;AACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACN;;;;;;GAMG;AACH,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kVACN,CAAC;AAER,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAyB3D,QAAA;AACE;;;;;;GAMG;AACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACN;;;;;;GAMG;AACH,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kVACN,CAAC;AAER,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC"}

package/dist/commonjs/diff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAGhC,YAAY,EAAE,WAAW,EAAE,CAAC;AAO5B;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,0CAA0C;IAC1C,MAAM,EAAE,OAAO,CAAC;IAChB,6CAA6C;IAC7C,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAC5B,UAAU,CAAC,CAAC,QAAQ,EACpB,SAAS,OAAO,KACf,UA4GF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GACvB,UAAU,OAAO,EACjB,QAAQ,OAAO,EACf,UAAS,WAAgB,KACxB,IAAI,GAAG,MAYT,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,OAAO,EACf,UAAU,OAAO,KAChB,OACoE,CAAC"}
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAGhC,YAAY,EAAE,WAAW,EAAE,CAAC;AAO5B;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,0CAA0C;IAC1C,MAAM,EAAE,OAAO,CAAC;IAChB,6CAA6C;IAC7C,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,GAC5B,UAAU,CAAC,CAAC,QAAQ,EACpB,SAAS,OAAO,KACf,UAiKF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GACvB,UAAU,OAAO,EACjB,QAAQ,OAAO,EACf,UAAS,WAAgB,KACxB,IAAI,GAAG,MAYT,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,OAAO,EACf,UAAU,OAAO,KAChB,OACoE,CAAC"}