bupkis 0.15.0 → 0.17.0

package/dist/assertion/impl/async.cjs

@@ -23,6 +23,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncAssertions = exports.AsyncParametricAssertions = void 0;
+const async_iterable_js_1 = require("./async-iterable.cjs");
 const async_parametric_js_1 = require("./async-parametric.cjs");
 /**
  * Tuple of all built-in `Promise`-based parametric assertions.
@@ -42,10 +43,14 @@ exports.AsyncParametricAssertions = [
     async_parametric_js_1.functionFulfillWithValueSatisfyingAssertion,
 ];
 /**
- * Tuple of all built-in async assertions (Promise only).
+ * Tuple of all built-in async assertions (Promise and async iterables).
  *
  * @group Assertion Collections
  */
-exports.AsyncAssertions = [...exports.AsyncParametricAssertions];
+exports.AsyncAssertions = [
+    ...exports.AsyncParametricAssertions,
+    ...async_iterable_js_1.AsyncIterableAssertions,
+];
+__exportStar(require("./async-iterable.cjs"), exports);
 __exportStar(require("./async-parametric.cjs"), exports);
 //# sourceMappingURL=async.js.map

package/dist/assertion/impl/async.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"async.js","sourceRoot":"","sources":["../../../src/assertion/impl/async.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;;;;;;;;;;;;;;;AAEH,gEAW+B;AAE/B;;;;GAIG;AACU,QAAA,yBAAyB,GAAG;IACvC,8CAAwB;IACxB,6CAAuB;IACvB,6CAAuB;IACvB,4CAAsB;IACtB,qDAA+B;IAC/B,oDAA8B;IAC9B,gEAA0C;IAC1C,+DAAyC;IACzC,gEAA0C;IAC1C,iEAA2C;CACnC,CAAC;AAEX;;;;GAIG;AACU,QAAA,eAAe,GAAG,CAAC,GAAG,iCAAyB,CAAU,CAAC;AAEvE,yDAAsC"}
+{"version":3,"file":"async.js","sourceRoot":"","sources":["../../../src/assertion/impl/async.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;;;;;;;;;;;;;;;AAEH,4DAA8D;AAC9D,gEAW+B;AAE/B;;;;GAIG;AACU,QAAA,yBAAyB,GAAG;IACvC,8CAAwB;IACxB,6CAAuB;IACvB,6CAAuB;IACvB,4CAAsB;IACtB,qDAA+B;IAC/B,oDAA8B;IAC9B,gEAA0C;IAC1C,+DAAyC;IACzC,gEAA0C;IAC1C,iEAA2C;CACnC,CAAC;AAEX;;;;GAIG;AACU,QAAA,eAAe,GAAG;IAC7B,GAAG,iCAAyB;IAC5B,GAAG,2CAAuB;CAClB,CAAC;AAEX,uDAAoC;AACpC,yDAAsC"}

package/dist/assertion/impl/async.d.cts

@@ -11,15 +11,15 @@
  *
  * @group Assertion Collections
  */
-export declare const AsyncParametricAssertions: readonly [import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").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<{
+export declare const AsyncParametricAssertions: readonly [import("../assertion-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<{
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<{
+} | undefined>, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<{
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject", "to be rejected"]], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
+} | undefined>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject", "to be rejected"]], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject", "to be rejected"]], (subject: PromiseLike<unknown>) => Promise<{
+} | undefined>, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject", "to be rejected"]], (subject: PromiseLike<unknown>) => Promise<{
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("../../types.js").Constructor) => Promise<{
+} | undefined>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("../assertion-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", "to be rejected with a", "to be rejected 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<{
     message: string;
     actual?: undefined;
     expected?: undefined;
@@ -27,7 +27,7 @@ export declare const AsyncParametricAssertions: readonly [import("../assertion-t
     actual: string;
     expected: string;
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("../../types.js").Constructor) => Promise<{
+} | undefined>, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
     actual?: undefined;
     expected?: undefined;
@@ -35,53 +35,53 @@ export declare const AsyncParametricAssertions: readonly [import("../assertion-t
     actual: string;
     expected: string;
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
+} | undefined>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-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 error satisfying", "to be rejected with error satisfying"], import("zod").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
     schema?: undefined;
     subject?: undefined;
 } | {
-    schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    schema: import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
     message?: undefined;
-}>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod/v4").ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
+}>, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod").ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
     schema?: undefined;
     subject?: undefined;
 } | {
-    schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    schema: import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
     message?: undefined;
-}>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
+}>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod").ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
     schema?: undefined;
     subject?: undefined;
 } | {
-    schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    schema: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
     subject: unknown;
     message?: undefined;
-}>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
+}>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
     schema?: undefined;
     subject?: undefined;
 } | {
-    schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    schema: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
     subject: unknown;
     message?: undefined;
-}>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnknown]>];
+}>, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod").ZodUnknown]>];
 /**
- * Tuple of all built-in async assertions (Promise only).
+ * Tuple of all built-in async assertions (Promise and async iterables).
  *
  * @group Assertion Collections
  */
-export declare const AsyncAssertions: readonly [import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").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<{
+export declare const AsyncAssertions: readonly [import("../assertion-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<{
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<{
+} | undefined>, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<{
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject", "to be rejected"]], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
+} | undefined>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject", "to be rejected"]], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject", "to be rejected"]], (subject: PromiseLike<unknown>) => Promise<{
+} | undefined>, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject", "to be rejected"]], (subject: PromiseLike<unknown>) => Promise<{
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("../../types.js").Constructor) => Promise<{
+} | undefined>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("../assertion-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", "to be rejected with a", "to be rejected 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<{
     message: string;
     actual?: undefined;
     expected?: undefined;
@@ -89,7 +89,7 @@ export declare const AsyncAssertions: readonly [import("../assertion-types.js").
     actual: string;
     expected: string;
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("../../types.js").Constructor) => Promise<{
+} | undefined>, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
     actual?: undefined;
     expected?: undefined;
@@ -97,38 +97,83 @@ export declare const AsyncAssertions: readonly [import("../assertion-types.js").
     actual: string;
     expected: string;
     message: string;
-} | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
+} | undefined>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-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 error satisfying", "to be rejected with error satisfying"], import("zod").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
     schema?: undefined;
     subject?: undefined;
 } | {
-    schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    schema: import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
     message?: undefined;
-}>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod/v4").ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
+}>, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod").ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
     schema?: undefined;
     subject?: undefined;
 } | {
-    schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    schema: import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
     message?: undefined;
-}>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
+}>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod").ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
     schema?: undefined;
     subject?: undefined;
 } | {
-    schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    schema: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
     subject: unknown;
     message?: undefined;
-}>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
+}>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
     schema?: undefined;
     subject?: undefined;
 } | {
-    schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    schema: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
     subject: unknown;
     message?: undefined;
-}>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnknown]>];
+}>, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to yield", "to emit", "to yield value satisfying"], import("zod").ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to yield", "to emit", "to yield value satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield value exhaustively satisfying", import("zod").ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield value exhaustively satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield items satisfying", import("zod").ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield items satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield items exhaustively satisfying", import("zod").ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield items exhaustively satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to yield first", "to yield first satisfying"], import("zod").ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to yield first", "to yield first satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield first exhaustively satisfying", import("zod").ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield first exhaustively satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to yield last", "to yield last satisfying"], import("zod").ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to yield last", "to yield last satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield last exhaustively satisfying", import("zod").ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield last exhaustively satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield count", import("zod").ZodInt], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expectedCount: number) => Promise<{
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield count">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield at least", import("zod").ZodInt], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, minCount: number) => Promise<{
+    actual: number;
+    expected: string;
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield at least">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield at most", import("zod").ZodInt], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, maxCount: number) => Promise<{
+    actual: number;
+    expected: string;
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield at most">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to be an empty iterable"], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>) => Promise<{
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to be an empty iterable">]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield exactly", import("zod").ZodArray<import("zod").ZodUnknown>], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown[]) => Promise<{
+    schema: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown[];
+}>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield exactly">, import("zod").ZodArray<import("zod").ZodUnknown>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to yield sequence satisfying", "to yield array satisfying"], import("zod").ZodArray<import("zod").ZodUnknown>], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown[]) => Promise<{
+    schema: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown[];
+}>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to yield sequence satisfying", "to yield array satisfying"]>, import("zod").ZodArray<import("zod").ZodUnknown>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to complete", "to finish"]], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>) => Promise<{
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to complete", "to finish"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to reject", "to be rejected"]], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>) => Promise<{
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to reject with a", "to reject with an"], import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expectedType: import("../../types.js").Constructor) => Promise<{
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod").ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expectedShape: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, import("zod").ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod").ZodUnknown]>];
+export * from "./async-iterable.cjs";
 export * from "./async-parametric.cjs";
 //# sourceMappingURL=async.d.ts.map

package/dist/assertion/impl/async.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/async.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAeH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8WAW5B,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8WAA0C,CAAC;AAEvE,uCAAsC"}
+{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/async.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAgBH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wWAW5B,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4cAGlB,CAAC;AAEX,qCAAoC;AACpC,uCAAsC"}