bupkis 0.18.2 → 1.0.0

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

@@ -0,0 +1,179 @@
+/**
+ * Re-exports all asynchronous assertions as assertion collections.
+ *
+ * @packageDocumentation
+ * @groupDescription Assertion Collections
+ * Collections of individual assertions. For those building on top of <span class="bupkis">BUPKIS</span>.
+ * @showGroups
+ */
+/**
+ * Tuple of all built-in `Promise`-based parametric assertions.
+ *
+ * @group Assertion Collections
+ */
+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").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").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").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").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;
+} | {
+    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("../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;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+} | 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").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: 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 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").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: undefined;
+}>, 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").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: undefined;
+}>, 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").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: 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 fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod").ZodUnknown]>];
+/**
+ * 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").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").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").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").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").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;
+} | {
+    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("../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;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+} | 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").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: 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 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").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: undefined;
+}>, 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").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: undefined;
+}>, 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").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: 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 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

@@ -0,0 +1 @@
+{"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"}

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

@@ -0,0 +1,179 @@
+/**
+ * Re-exports all asynchronous assertions as assertion collections.
+ *
+ * @packageDocumentation
+ * @groupDescription Assertion Collections
+ * Collections of individual assertions. For those building on top of <span class="bupkis">BUPKIS</span>.
+ * @showGroups
+ */
+/**
+ * Tuple of all built-in `Promise`-based parametric assertions.
+ *
+ * @group Assertion Collections
+ */
+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").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").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").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").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;
+} | {
+    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("../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;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+} | 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").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: 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 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").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: undefined;
+}>, 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").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: undefined;
+}>, 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").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: 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 fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod").ZodUnknown]>];
+/**
+ * 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").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").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").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").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").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;
+} | {
+    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("../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;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+} | 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").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: 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 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").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: undefined;
+}>, 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").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: undefined;
+}>, 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").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: 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 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.js";
+export * from "./async-parametric.js";
+//# sourceMappingURL=async.d.ts.map

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

@@ -0,0 +1 @@
+{"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,oCAAoC;AACpC,sCAAsC"}

package/dist/assertion/impl/async.js

@@ -0,0 +1,39 @@
+/**
+ * Re-exports all asynchronous assertions as assertion collections.
+ *
+ * @packageDocumentation
+ * @groupDescription Assertion Collections
+ * Collections of individual assertions. For those building on top of <span class="bupkis">BUPKIS</span>.
+ * @showGroups
+ */
+import { AsyncIterableAssertions } from "./async-iterable.js";
+import { functionFulfillWithValueSatisfyingAssertion, functionRejectAssertion, functionRejectWithErrorSatisfyingAssertion, functionRejectWithTypeAssertion, functionResolveAssertion, promiseRejectAssertion, promiseRejectWithErrorSatisfyingAssertion, promiseRejectWithTypeAssertion, promiseResolveAssertion, promiseResolveWithValueSatisfyingAssertion, } from "./async-parametric.js";
+/**
+ * Tuple of all built-in `Promise`-based parametric assertions.
+ *
+ * @group Assertion Collections
+ */
+export const AsyncParametricAssertions = [
+    functionResolveAssertion,
+    promiseResolveAssertion,
+    functionRejectAssertion,
+    promiseRejectAssertion,
+    functionRejectWithTypeAssertion,
+    promiseRejectWithTypeAssertion,
+    functionRejectWithErrorSatisfyingAssertion,
+    promiseRejectWithErrorSatisfyingAssertion,
+    promiseResolveWithValueSatisfyingAssertion,
+    functionFulfillWithValueSatisfyingAssertion,
+];
+/**
+ * Tuple of all built-in async assertions (Promise and async iterables).
+ *
+ * @group Assertion Collections
+ */
+export const AsyncAssertions = [
+    ...AsyncParametricAssertions,
+    ...AsyncIterableAssertions,
+];
+export * from "./async-iterable.js";
+export * from "./async-parametric.js";
+//# sourceMappingURL=async.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async.js","sourceRoot":"","sources":["../../../src/assertion/impl/async.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,uBAAuB,EAAE,4BAA4B;AAC9D,OAAO,EACL,2CAA2C,EAC3C,uBAAuB,EACvB,0CAA0C,EAC1C,+BAA+B,EAC/B,wBAAwB,EACxB,sBAAsB,EACtB,yCAAyC,EACzC,8BAA8B,EAC9B,uBAAuB,EACvB,0CAA0C,GAC3C,8BAA8B;AAE/B;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,wBAAwB;IACxB,uBAAuB;IACvB,uBAAuB;IACvB,sBAAsB;IACtB,+BAA+B;IAC/B,8BAA8B;IAC9B,0CAA0C;IAC1C,yCAAyC;IACzC,0CAA0C;IAC1C,2CAA2C;CACnC,CAAC;AAEX;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,GAAG,yBAAyB;IAC5B,GAAG,uBAAuB;CAClB,CAAC;AAEX,oCAAoC;AACpC,sCAAsC"}

package/dist/assertion/impl/index.cjs

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * This namespace contains all of <span class="bupkis">BUPKIS</span>' built-in
+ * assertions.
+ *
+ * Each implements {@link bupkis!types.Assertion | Assertion}. While these
+ * contain example usage, it may be more helpful to refer to the [Assertions
+ * Reference](/assertions); these are exposed for those building on top of <span
+ * class="bupkis">BUPKIS</span>.
+ *
+ * @packageDocumentation
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./async-parametric.cjs"), exports);
+__exportStar(require("./async.cjs"), exports);
+__exportStar(require("./snapshot.cjs"), exports);
+__exportStar(require("./sync-basic.cjs"), exports);
+__exportStar(require("./sync-collection.cjs"), exports);
+__exportStar(require("./sync-date.cjs"), exports);
+__exportStar(require("./sync-esoteric.cjs"), exports);
+__exportStar(require("./sync-parametric.cjs"), exports);
+__exportStar(require("./sync.cjs"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/assertion/impl/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;;;;;;;;;;;;;;AAEH,yDAAsC;AACtC,8CAA2B;AAC3B,iDAA8B;AAC9B,mDAAgC;AAChC,wDAAqC;AACrC,kDAA+B;AAC/B,sDAAmC;AACnC,wDAAqC;AACrC,6CAA0B"}

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

@@ -0,0 +1,21 @@
+/**
+ * This namespace contains all of <span class="bupkis">BUPKIS</span>' built-in
+ * assertions.
+ *
+ * Each implements {@link bupkis!types.Assertion | Assertion}. While these
+ * contain example usage, it may be more helpful to refer to the [Assertions
+ * Reference](/assertions); these are exposed for those building on top of <span
+ * class="bupkis">BUPKIS</span>.
+ *
+ * @packageDocumentation
+ */
+export * from "./async-parametric.cjs";
+export * from "./async.cjs";
+export * from "./snapshot.cjs";
+export * from "./sync-basic.cjs";
+export * from "./sync-collection.cjs";
+export * from "./sync-date.cjs";
+export * from "./sync-esoteric.cjs";
+export * from "./sync-parametric.cjs";
+export * from "./sync.cjs";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,uCAAsC;AACtC,4BAA2B;AAC3B,+BAA8B;AAC9B,iCAAgC;AAChC,sCAAqC;AACrC,gCAA+B;AAC/B,oCAAmC;AACnC,sCAAqC;AACrC,2BAA0B"}