bupkis 0.18.1 → 0.18.2

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

@@ -1,560 +0,0 @@
-/**
- * Parameterized assertions for comparisons, function behavior, and complex
- * validation.
- *
- * These assertions accept additional parameters to customize their behavior,
- * including numeric comparisons, string matching, object satisfaction, function
- * throwing behavior, and deep equality checks.
- *
- * @packageDocumentation
- * @groupDescription Parametric Assertions (Sync)
- * Complex assertions that accept parameters for customized validation behavior.
- *
- * @showGroups
- */
-import { z } from 'zod';
-import { type Constructor } from "../../types.js";
-/**
- * Assertion for testing if a value is an instance of a specific constructor.
- *
- * @example
- *
- * ```typescript
- * expect(new Date(), 'to be an instance of', Date); // passes
- * expect('hello', 'to be a', String); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const instanceOfAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a", "to be an"], z.ZodCustom<Constructor, Constructor>], (_: unknown, ctor: Constructor) => z.ZodCustom<Constructor, Constructor>, never>;
-/**
- * Assertion for testing if a value is of a specific built-in type.
- *
- * @example
- *
- * ```typescript
- * expect('hello', 'to be a', 'string'); // passes
- * expect(42, 'to be an', 'Array'); // fails
- * expect([], 'to be a', 'array'); // passes
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const typeOfAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnknown, readonly ["to be a", "to be an", "to have type"], z.ZodEnum<{
-    [x: string]: string;
-}>], (_: unknown, type: string) => z.ZodString | z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown> | z.ZodNumber | z.ZodSymbol | z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | z.ZodBoolean | z.ZodBigInt | z.ZodNull | z.ZodUndefined | z.ZodCustom<RegExp, RegExp> | z.ZodDate | z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | z.ZodArray<z.ZodUnknown> | z.ZodCustom<Error, Error> | z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>> | z.ZodObject<{}, z.core.$loose>, readonly [z.ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, z.ZodEnum<{
-    [x: string]: string;
-}>]>;
-/**
- * Assertion for testing if a number is greater than another number.
- *
- * @example
- *
- * ```typescript
- * expect(5, 'to be greater than', 3); // passes
- * expect(2, 'to be greater than', 5); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const numberGreaterThanAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodNumber, "to be greater than", z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("../assertion-types.js").PhraseLiteralSlot<"to be greater than">, z.ZodNumber]>;
-/**
- * Assertion for testing if a number is less than another number.
- *
- * @example
- *
- * ```typescript
- * expect(3, 'to be less than', 5); // passes
- * expect(5, 'to be less than', 2); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const numberLessThanAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be less than", "to be lt"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be less than", "to be lt"]>, z.ZodNumber]>;
-/**
- * Assertion for testing if a number is greater than or equal to another number.
- *
- * @example
- *
- * ```typescript
- * expect(5, 'to be greater than or equal to', 5); // passes
- * expect(5, 'to be at least', 3); // passes
- * expect(2, 'to be at least', 5); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const numberGreaterThanOrEqualAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be greater than or equal to", "to be at least", "to be gte"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be greater than or equal to", "to be at least", "to be gte"]>, z.ZodNumber]>;
-/**
- * Assertion for testing if a number is less than or equal to another number.
- *
- * @example
- *
- * ```typescript
- * expect(3, 'to be less than or equal to', 5); // passes
- * expect(5, 'to be at most', 5); // passes
- * expect(7, 'to be at most', 5); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const numberLessThanOrEqualAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be less than or equal to", "to be at most", "to be lte"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be less than or equal to", "to be at most", "to be lte"]>, z.ZodNumber]>;
-/**
- * Assertion for testing if a number is within a specific range (inclusive).
- *
- * @example
- *
- * ```typescript
- * expect(5, 'to be within', 1, 10); // passes
- * expect(15, 'to be between', 1, 10); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const numberWithinRangeAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be within", "to be between"], z.ZodNumber, z.ZodNumber], (subject: number, min: number, max: number) => {
-    message: string;
-} | undefined, readonly [z.ZodNumber, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>, z.ZodNumber, z.ZodNumber]>;
-/**
- * Assertion for testing if a number is close to another number within a
- * tolerance.
- *
- * @example
- *
- * ```typescript
- * expect(1.0001, 'to be close to', 1.0, 0.001); // passes
- * expect(1.1, 'to be close to', 1.0, 0.01); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const numberCloseToAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodNumber, "to be close to", z.ZodNumber, z.ZodOptional<z.ZodNumber>], (subject: number, expected: number, tolerance?: number | undefined) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [z.ZodNumber, import("../assertion-types.js").PhraseLiteralSlot<"to be close to">, z.ZodNumber, z.ZodOptional<z.ZodNumber>]>;
-/**
- * Assertion for testing if a string is lexicographically greater than another
- * string.
- *
- * @example
- *
- * ```typescript
- * expect('b', 'to be greater than', 'a'); // passes
- * expect('apple', 'to be greater than', 'banana'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const stringGreaterThanAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodString, "to be greater than", z.ZodString], (subject: string, other: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be greater than">, z.ZodString]>;
-/**
- * Assertion for testing if a string is lexicographically less than another
- * string.
- *
- * @example
- *
- * ```typescript
- * expect('a', 'to be less than', 'b'); // passes
- * expect('banana', 'to be less than', 'apple'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const stringLessThanAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodString, "to be less than", z.ZodString], (subject: string, other: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be less than">, z.ZodString]>;
-/**
- * Assertion for testing if a string is lexicographically greater than or equal
- * to another string.
- *
- * @example
- *
- * ```typescript
- * expect('b', 'to be greater than or equal to', 'a'); // passes
- * expect('a', 'to be greater than or equal to', 'a'); // passes
- * expect('a', 'to be greater than or equal to', 'b'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const stringGreaterThanOrEqualAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodString, "to be greater than or equal to", z.ZodString], (subject: string, other: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be greater than or equal to">, z.ZodString]>;
-/**
- * Assertion for testing if a string is lexicographically less than or equal to
- * another string.
- *
- * @example
- *
- * ```typescript
- * expect('a', 'to be less than or equal to', 'b'); // passes
- * expect('a', 'to be less than or equal to', 'a'); // passes
- * expect('b', 'to be less than or equal to', 'a'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const stringLessThanOrEqualAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodString, "to be less than or equal to", z.ZodString], (subject: string, other: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be less than or equal to">, z.ZodString]>;
-/**
- * Assertion for testing if a string begins with a specific prefix.
- *
- * @example
- *
- * ```typescript
- * expect('hello world', 'to begin with', 'hello'); // passes
- * expect('hello world', 'to start with', 'world'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const stringBeginsWithAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodString, readonly ["to begin with", "to start with"], z.ZodString], (subject: string, prefix: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>, z.ZodString]>;
-/**
- * Assertion for testing if a string ends with a specific suffix.
- *
- * @example
- *
- * ```typescript
- * expect('hello world', 'to end with', 'world'); // passes
- * expect('hello world', 'to end with', 'hello'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const stringEndsWithAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodString, "to end with", z.ZodString], (subject: string, suffix: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to end with">, z.ZodString]>;
-/**
- * Assertion for testing if a value is one of a specific set of values.
- *
- * @example
- *
- * ```typescript
- * expect('red', 'to be one of', ['red', 'green', 'blue']); // passes
- * expect('yellow', 'to be one of', ['red', 'green', 'blue']); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const oneOfAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly ["to be one of", z.ZodArray<z.ZodUnknown>], (subject: unknown, values: unknown[]) => {
-    actual: unknown;
-    expected: unknown[];
-    message: string;
-} | undefined, never>;
-/**
- * Assertion for testing if a function has a specific arity (number of
- * parameters).
- *
- * @example
- *
- * ```typescript
- * expect((a, b) => a + b, 'to have arity', 2); // passes
- * expect((a, b, c) => a + b + c, 'to have arity', 2); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const functionArityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", z.ZodInt], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have arity">, z.ZodInt]>;
-/**
- * Assertion for testing if an Error has a specific message.
- *
- * @example
- *
- * ```typescript
- * expect(new Error('oops'), 'to have message', 'oops'); // passes
- * expect(new Error('oops'), 'to have message', 'wrong'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const errorMessageAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Error, Error>, "to have message", z.ZodString], (subject: Error, expectedMessage: string) => {
-    actual: string;
-    expected: string;
-    message: string;
-} | undefined, readonly [z.ZodCustom<Error, Error>, import("../assertion-types.js").PhraseLiteralSlot<"to have message">, z.ZodString]>;
-/**
- * Assertion for testing if an Error has a message matching a regular
- * expression.
- *
- * @example
- *
- * ```typescript
- * expect(
- *   new Error('Error: something went wrong'),
- *   'to have message matching',
- *   /something/,
- * ); // passes
- * expect(new Error('All good'), 'to have message matching', /error/i); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const errorMessageMatchingAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<Error, Error>, "to have message matching", z.ZodCustom<RegExp, RegExp>], (subject: Error, pattern: RegExp) => {
-    message: string;
-} | undefined, readonly [z.ZodCustom<Error, Error>, import("../assertion-types.js").PhraseLiteralSlot<"to have message matching">, z.ZodCustom<RegExp, RegExp>]>;
-/**
- * Assertion for testing strict equality between two values.
- *
- * @example
- *
- * ```typescript
- * expect(42, 'to be', 42); // passes
- * expect('hello', 'to equal', 'hello'); // passes
- * expect({}, 'to be', {}); // fails (different object references)
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const strictEqualityAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal", "is strictly equal to"], z.ZodUnknown], (subject: unknown, value: unknown) => {
-    actual: unknown;
-    expected: unknown;
-    message: string;
-} | undefined, never>;
-/**
- * Assertion for testing deep equality between any values.
- *
- * Works with primitives, objects, arrays, Maps, Sets, and other types.
- *
- * @example
- *
- * ```typescript
- * // Primitives
- * expect(42, 'to deep equal', 42); // passes
- * expect('hello', 'to deeply equal', 'world'); // fails
- *
- * // Objects
- * expect({ a: 1, b: 2 }, 'to deep equal', { a: 1, b: 2 }); // passes
- * expect({ a: 1 }, 'to deeply equal', { a: 1, b: 2 }); // fails
- *
- * // Arrays
- * expect([1, 2, 3], 'to deep equal', [1, 2, 3]); // passes
- *
- * // Maps and Sets
- * expect(new Map([['a', 1]]), 'to deep equal', new Map([['a', 1]])); // passes
- * expect(new Set([1, 2]), 'to deeply equal', new Set([1, 2])); // passes
- * ```
- *
- * @group Parametric Assertions (Sync)
- * @bupkisAnchor unknown-to-deep-equal-any
- * @bupkisAssertionCategory equality
- */
-export declare const deepEqualAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to deep equal", "to deeply equal"], z.ZodUnknown], (_: unknown, expected: unknown) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, never>;
-/**
- * Assertion for testing if a function throws an error when called.
- *
- * @example
- *
- * ```typescript
- * expect(() => {
- *   throw new Error('oops');
- * }, 'to throw'); // passes
- * expect(() => 'hello', 'to throw'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- * @bupkisAnchor function-to-throw-any
- * @bupkisAssertionCategory function
- * @bupkisRedirect to-throw
- */
-export declare const functionThrowsAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, "to throw"], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown) => {
-    message: string;
-} | undefined, readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralSlot<"to throw">]>;
-/**
- * Assertion for testing if a function throws an error of a specific type.
- *
- * @example
- *
- * ```typescript
- * expect(
- *   () => {
- *     throw new TypeError('wrong type');
- *   },
- *   'to throw a',
- *   TypeError,
- * ); // passes
- * expect(
- *   () => {
- *     throw new Error('oops');
- *   },
- *   'to throw an',
- *   TypeError,
- * ); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const functionThrowsTypeAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], z.ZodCustom<Constructor, Constructor>], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: Constructor) => {
-    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 throw a", "to throw an"]>, z.ZodCustom<Constructor, Constructor>]>;
-/**
- * Assertion for testing if a function throws an error matching specific
- * criteria.
- *
- * @example
- *
- * ```typescript
- * expect(
- *   () => {
- *     throw new Error('oops');
- *   },
- *   'to throw',
- *   'oops',
- * ); // passes
- * expect(
- *   () => {
- *     throw new Error('fail');
- *   },
- *   'to throw',
- *   /error/i,
- * ); // passes
- * expect(
- *   () => {
- *     throw new Error('oops');
- *   },
- *   'to throw',
- *   { message: 'oops' },
- * ); // passes
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const functionThrowsSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw", "to throw error satisfying"], z.ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => {
-    message: string;
-    schema?: undefined;
-    subject?: undefined;
-} | {
-    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, 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 throw", "to throw error satisfying"]>, z.ZodUnknown]>;
-/**
- * Assertion for testing if a function throws an error of a specific type that
- * also matches criteria.
- *
- * @example
- *
- * ```typescript
- * expect(
- *   () => {
- *     throw new TypeError('wrong type');
- *   },
- *   'to throw a',
- *   TypeError,
- *   'satisfying',
- *   { message: 'wrong type' },
- * ); // passes
- * expect(
- *   () => {
- *     throw new Error('oops');
- *   },
- *   'to throw an',
- *   TypeError,
- *   'satisfying',
- *   /type/,
- * ); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const functionThrowsTypeSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], z.ZodCustom<Constructor, Constructor>, "satisfying", z.ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: Constructor, param: unknown) => {
-    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 throw a", "to throw an"]>, z.ZodCustom<Constructor, Constructor>, import("../assertion-types.js").PhraseLiteralSlot<"satisfying">, z.ZodUnknown]>;
-/**
- * Assertion for testing if a string includes/contains another string.
- *
- * @example
- *
- * ```typescript
- * expect('hello world', 'includes', 'world'); // passes
- * expect('hello world', 'contains', 'foo'); // fails
- * expect('hello world', 'to include', 'hello'); // passes
- * expect('hello world', 'to contain', 'bar'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const stringIncludesAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodString, readonly ["includes", "contains", "to include", "to contain"], z.ZodString], (subject: string, expected: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, z.ZodString]>;
-/**
- * Assertion for testing if a string matches a regular expression.
- *
- * @example
- *
- * ```typescript
- * expect('hello123', 'to match', /\d+/); // passes
- * expect('hello', 'to match', /\d+/); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-export declare const stringMatchesAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodString, "to match", z.ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to match">, z.ZodCustom<RegExp, RegExp>]>;
-/**
- * Assertion for testing if a string has a specific length.
- *
- * @example
- *
- * ```typescript
- * expect('hello', 'to have length', 5); // passes
- * expect('hi', 'to have length', 5); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- * @bupkisAnchor string-to-have-length
- * @bupkisAssertionCategory strings
- */
-export declare const stringLengthAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodString, "to have length", z.ZodInt], (subject: string, expectedLength: number) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to have length">, z.ZodInt]>;
-/**
- * Assertion for testing if a value satisfies a pattern or shape.
- *
- * Works with any value type: primitives, objects, arrays, or cross-type checks.
- * Uses partial matching semantics - extra properties are allowed in objects.
- *
- * @example
- *
- * ```typescript
- * // Primitives
- * expect(42, 'to satisfy', 42); // passes
- * expect('hello', 'satisfies', 'hello'); // passes
- *
- * // Objects (partial matching)
- * expect({ name: 'John', age: 30 }, 'to satisfy', { name: 'John' }); // passes
- * expect({ name: 'John' }, 'to be like', { name: 'John', age: 30 }); // fails
- *
- * // Arrays
- * expect([1, 2, 3], 'to satisfy', [1, 2, 3]); // passes
- *
- * // Cross-type satisfaction
- * expect([1, 2, 3], 'to satisfy', { length: 3 }); // passes
- * ```
- *
- * @group Parametric Assertions (Sync)
- * @bupkisAnchor unknown-to-satisfy-any
- * @bupkisAssertionCategory equality
- */
-export declare const satisfiesAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to satisfy", "to be like", "satisfies"], z.ZodUnknown], (_subject: unknown, shape: unknown) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, never>;
-//# sourceMappingURL=sync-parametric.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sync-parametric.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/sync-parametric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8BxB,OAAO,EAAE,KAAK,WAAW,EAAE,uBAAuB;AAuClD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,oPAG/B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe;;;;IA2D3B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B,2QAGtC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB,yTAGnC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iCAAiC,6XAO7C,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,8BAA8B,qXAO1C,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B;;qKAStC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB;;;;oJAYlC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,0BAA0B;;4HAStC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,uBAAuB;;yHASnC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iCAAiC;;wIAS7C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,8BAA8B;;qIAS1C,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB;;yJASrC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB;;qHASnC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc;;;;qBAW1B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB;;;;8QAWlC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB;;;;uIAWjC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,6BAA6B;;gKASzC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,uBAAuB;;;;qBAsBnC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,kBAAkB,0OAG9B,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB;;+PAUnC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;wUAyBvC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;+SAyB7C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;2YAoCjD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB;;2KAanC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,yRAGlC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB;;;;qHAajC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,kBAAkB,mPAG9B,CAAC"}