bupkis 0.18.3 → 1.0.0

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

@@ -0,0 +1,560 @@
+/**
+ * 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<Map<unknown, unknown>, Map<unknown, unknown>> | z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | z.ZodNumber | z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | z.ZodArray<z.ZodUnknown> | z.ZodSymbol | z.ZodCustom<RegExp, RegExp> | z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown> | z.ZodBigInt | z.ZodBoolean | z.ZodDate | z.ZodCustom<Error, Error> | z.ZodNull | z.ZodUndefined | z.ZodObject<{}, z.core.$loose> | z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>, 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

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