bupkis 0.18.3 → 1.0.0

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

@@ -0,0 +1,278 @@
+/**
+ * Asynchronous assertion implementations.
+ *
+ * This module contains all built-in asynchronous assertion implementations for
+ * working with Promises and async operations. It provides assertions for
+ * Promise resolution, rejection, and async function behavior validation with
+ * comprehensive error handling.
+ *
+ * @module
+ * @groupDescription Parametric Assertions (Async)
+ * Asynchronous assertions for Promise resolution, rejection, and async function behavior.
+ *
+ * @showGroups
+ */
+import { type z } from 'zod';
+/**
+ * Assertion for testing if a function returns a fulfilled Promise.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(() => Promise.resolve('success'), 'to resolve'); // passes
+ * await expectAsync(() => Promise.reject('error'), 'to fulfill'); // fails
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ * @bupkisAnchor function-to-resolve
+ * @bupkisAssertionCategory promise
+ */
+export declare const functionResolveAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.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 [z.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"]>]>;
+/**
+ * Assertion for testing if a Promise is fulfilled.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(Promise.resolve('success'), 'to resolve'); // passes
+ * await expectAsync(Promise.reject('error'), 'to fulfill'); // fails
+ * ```
+ *
+ * @bupkisAssertionCategory promise
+ * @bupkisAnchor promise-to-resolve
+ * @group Parametric Assertions (Async)
+ */
+export declare const promiseResolveAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>;
+/**
+ * Assertion for testing if a function returns a rejected Promise.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(() => Promise.reject('error'), 'to reject'); // passes
+ * await expectAsync(() => Promise.resolve('success'), 'to reject'); // fails
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const functionRejectAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.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 [z.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"]>]>;
+/**
+ * Assertion for testing if a Promise is rejected.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(Promise.reject('error'), 'to reject'); // passes
+ * await expectAsync(Promise.resolve('success'), 'to reject'); // fails
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const promiseRejectAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject", "to be rejected"]], (subject: PromiseLike<unknown>) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>;
+/**
+ * Assertion for testing if a function rejects with a specific error type.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(
+ *   () => Promise.reject(new TypeError('wrong')),
+ *   'to reject with a',
+ *   TypeError,
+ * ); // passes
+ * await expectAsync(
+ *   () => Promise.reject(new Error('wrong')),
+ *   'to reject with an',
+ *   TypeError,
+ * ); // fails
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const functionRejectWithTypeAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.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"], z.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 [z.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"]>, z.ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>;
+/**
+ * Assertion for testing if a Promise rejects with a specific error type.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(
+ *   Promise.reject(new TypeError('wrong')),
+ *   'to reject with a',
+ *   TypeError,
+ * ); // passes
+ * await expectAsync(
+ *   Promise.reject(new Error('wrong')),
+ *   'to reject with an',
+ *   TypeError,
+ * ); // fails
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const promiseRejectWithTypeAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], z.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 [z.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"]>, z.ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>;
+/**
+ * Assertion for testing if a function rejects with an error satisfying specific
+ * criteria.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(
+ *   () => Promise.reject(new Error('oops')),
+ *   'to reject with error satisfying',
+ *   'oops',
+ * ); // passes
+ * await expectAsync(
+ *   () => Promise.reject(new Error('fail')),
+ *   'to reject with error satisfying',
+ *   /error/i,
+ * ); // passes
+ * await expectAsync(
+ *   () => Promise.reject(new Error('oops')),
+ *   'to reject with error satisfying',
+ *   { message: 'oops' },
+ * ); // passes
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const functionRejectWithErrorSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.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"], z.ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: undefined;
+}>, readonly [z.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"]>, z.ZodUnknown]>;
+/**
+ * Assertion for testing if a Promise rejects with an error satisfying specific
+ * criteria.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(
+ *   Promise.reject(new Error('oops')),
+ *   'to reject with error satisfying',
+ *   'oops',
+ * ); // passes
+ * await expectAsync(
+ *   Promise.reject(new Error('fail')),
+ *   'to reject with error satisfying',
+ *   /error/i,
+ * ); // passes
+ * await expectAsync(
+ *   Promise.reject(new Error('oops')),
+ *   'to reject with error satisfying',
+ *   { message: 'oops' },
+ * ); // passes
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const promiseRejectWithErrorSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], z.ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: undefined;
+}>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, z.ZodUnknown]>;
+/**
+ * Assertion for testing if a Promise fulfills with a value satisfying specific
+ * criteria.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(
+ *   Promise.resolve('hello'),
+ *   'to fulfill with value satisfying',
+ *   'hello',
+ * ); // passes
+ * await expectAsync(
+ *   Promise.resolve('world'),
+ *   'to resolve with value satisfying',
+ *   /wor/,
+ * ); // passes
+ * await expectAsync(
+ *   Promise.resolve({ name: 'John' }),
+ *   'to fulfill with value satisfying',
+ *   { name: 'John' },
+ * ); // passes
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const promiseResolveWithValueSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: undefined;
+}>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnknown]>;
+/**
+ * Assertion for testing if a function returns a Promise that fulfills with a
+ * value satisfying specific criteria.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(
+ *   () => Promise.resolve('hello'),
+ *   'to fulfill with value satisfying',
+ *   'hello',
+ * ); // passes
+ * await expectAsync(
+ *   () => Promise.resolve('world'),
+ *   'to resolve with value satisfying',
+ *   /wor/,
+ * ); // passes
+ * await expectAsync(
+ *   () => Promise.resolve({ name: 'John' }),
+ *   'to fulfill with value satisfying',
+ *   { name: 'John' },
+ * ); // passes
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const functionFulfillWithValueSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.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"], z.ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: undefined;
+}>, readonly [z.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"]>, z.ZodUnknown]>;
+//# sourceMappingURL=async-parametric.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-parametric.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/async-parametric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC;AAkB7B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB;;iSAWpC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB;;mLAWnC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB;;oSAUnC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB;;sLAUlC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;0bAkC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;4UAkC1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,0CAA0C;;;;;;;;kVA4BtD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,yCAAyC;;;;;;;;oOA2BrD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,0CAA0C;;;;;;;;iOAyBtD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,2CAA2C;;;;;;;;+UAwBvD,CAAC"}

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

@@ -0,0 +1,278 @@
+/**
+ * Asynchronous assertion implementations.
+ *
+ * This module contains all built-in asynchronous assertion implementations for
+ * working with Promises and async operations. It provides assertions for
+ * Promise resolution, rejection, and async function behavior validation with
+ * comprehensive error handling.
+ *
+ * @module
+ * @groupDescription Parametric Assertions (Async)
+ * Asynchronous assertions for Promise resolution, rejection, and async function behavior.
+ *
+ * @showGroups
+ */
+import { type z } from 'zod';
+/**
+ * Assertion for testing if a function returns a fulfilled Promise.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(() => Promise.resolve('success'), 'to resolve'); // passes
+ * await expectAsync(() => Promise.reject('error'), 'to fulfill'); // fails
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ * @bupkisAnchor function-to-resolve
+ * @bupkisAssertionCategory promise
+ */
+export declare const functionResolveAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.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 [z.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"]>]>;
+/**
+ * Assertion for testing if a Promise is fulfilled.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(Promise.resolve('success'), 'to resolve'); // passes
+ * await expectAsync(Promise.reject('error'), 'to fulfill'); // fails
+ * ```
+ *
+ * @bupkisAssertionCategory promise
+ * @bupkisAnchor promise-to-resolve
+ * @group Parametric Assertions (Async)
+ */
+export declare const promiseResolveAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>;
+/**
+ * Assertion for testing if a function returns a rejected Promise.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(() => Promise.reject('error'), 'to reject'); // passes
+ * await expectAsync(() => Promise.resolve('success'), 'to reject'); // fails
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const functionRejectAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.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 [z.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"]>]>;
+/**
+ * Assertion for testing if a Promise is rejected.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(Promise.reject('error'), 'to reject'); // passes
+ * await expectAsync(Promise.resolve('success'), 'to reject'); // fails
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const promiseRejectAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject", "to be rejected"]], (subject: PromiseLike<unknown>) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>;
+/**
+ * Assertion for testing if a function rejects with a specific error type.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(
+ *   () => Promise.reject(new TypeError('wrong')),
+ *   'to reject with a',
+ *   TypeError,
+ * ); // passes
+ * await expectAsync(
+ *   () => Promise.reject(new Error('wrong')),
+ *   'to reject with an',
+ *   TypeError,
+ * ); // fails
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const functionRejectWithTypeAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.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"], z.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 [z.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"]>, z.ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>;
+/**
+ * Assertion for testing if a Promise rejects with a specific error type.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(
+ *   Promise.reject(new TypeError('wrong')),
+ *   'to reject with a',
+ *   TypeError,
+ * ); // passes
+ * await expectAsync(
+ *   Promise.reject(new Error('wrong')),
+ *   'to reject with an',
+ *   TypeError,
+ * ); // fails
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const promiseRejectWithTypeAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], z.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 [z.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"]>, z.ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>;
+/**
+ * Assertion for testing if a function rejects with an error satisfying specific
+ * criteria.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(
+ *   () => Promise.reject(new Error('oops')),
+ *   'to reject with error satisfying',
+ *   'oops',
+ * ); // passes
+ * await expectAsync(
+ *   () => Promise.reject(new Error('fail')),
+ *   'to reject with error satisfying',
+ *   /error/i,
+ * ); // passes
+ * await expectAsync(
+ *   () => Promise.reject(new Error('oops')),
+ *   'to reject with error satisfying',
+ *   { message: 'oops' },
+ * ); // passes
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const functionRejectWithErrorSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.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"], z.ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: undefined;
+}>, readonly [z.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"]>, z.ZodUnknown]>;
+/**
+ * Assertion for testing if a Promise rejects with an error satisfying specific
+ * criteria.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(
+ *   Promise.reject(new Error('oops')),
+ *   'to reject with error satisfying',
+ *   'oops',
+ * ); // passes
+ * await expectAsync(
+ *   Promise.reject(new Error('fail')),
+ *   'to reject with error satisfying',
+ *   /error/i,
+ * ); // passes
+ * await expectAsync(
+ *   Promise.reject(new Error('oops')),
+ *   'to reject with error satisfying',
+ *   { message: 'oops' },
+ * ); // passes
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const promiseRejectWithErrorSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], z.ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: undefined;
+}>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, z.ZodUnknown]>;
+/**
+ * Assertion for testing if a Promise fulfills with a value satisfying specific
+ * criteria.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(
+ *   Promise.resolve('hello'),
+ *   'to fulfill with value satisfying',
+ *   'hello',
+ * ); // passes
+ * await expectAsync(
+ *   Promise.resolve('world'),
+ *   'to resolve with value satisfying',
+ *   /wor/,
+ * ); // passes
+ * await expectAsync(
+ *   Promise.resolve({ name: 'John' }),
+ *   'to fulfill with value satisfying',
+ *   { name: 'John' },
+ * ); // passes
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const promiseResolveWithValueSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: undefined;
+}>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnknown]>;
+/**
+ * Assertion for testing if a function returns a Promise that fulfills with a
+ * value satisfying specific criteria.
+ *
+ * @example
+ *
+ * ```typescript
+ * await expectAsync(
+ *   () => Promise.resolve('hello'),
+ *   'to fulfill with value satisfying',
+ *   'hello',
+ * ); // passes
+ * await expectAsync(
+ *   () => Promise.resolve('world'),
+ *   'to resolve with value satisfying',
+ *   /wor/,
+ * ); // passes
+ * await expectAsync(
+ *   () => Promise.resolve({ name: 'John' }),
+ *   'to fulfill with value satisfying',
+ *   { name: 'John' },
+ * ); // passes
+ * ```
+ *
+ * @group Parametric Assertions (Async)
+ */
+export declare const functionFulfillWithValueSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.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"], z.ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: undefined;
+}>, readonly [z.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"]>, z.ZodUnknown]>;
+//# sourceMappingURL=async-parametric.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-parametric.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/async-parametric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC;AAkB7B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB;;iSAWpC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB;;mLAWnC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB;;oSAUnC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB;;sLAUlC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;0bAkC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;4UAkC1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,0CAA0C;;;;;;;;kVA4BtD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,yCAAyC;;;;;;;;oOA2BrD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,0CAA0C;;;;;;;;iOAyBtD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,2CAA2C;;;;;;;;+UAwBvD,CAAC"}