bupkis 0.18.0 → 0.18.2

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

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

@@ -1 +0,0 @@
-{"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;AAmB7B;;;;;;;;;;;;;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;;;;;;;;kVAoCtD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,yCAAyC;;;;;;;;oOAmCrD,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

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

@@ -1 +0,0 @@
-{"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;AAmB7B;;;;;;;;;;;;;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;;;;;;;;kVAoCtD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,yCAAyC;;;;;;;;oOAmCrD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,0CAA0C;;;;;;;;iOAyBtD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,2CAA2C;;;;;;;;+UAwBvD,CAAC"}