bupkis 0.18.1 → 0.18.2

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

@@ -1,179 +0,0 @@
-/**
- * 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

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

@@ -1,179 +0,0 @@
-/**
- * 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

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

@@ -1,39 +0,0 @@
-/**
- * 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

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

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

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

@@ -1,21 +0,0 @@
-/**
- * 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

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