bupkis 0.18.3 → 1.0.0

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

@@ -0,0 +1,536 @@
+/**
+ * Synchronous assertion implementations.
+ *
+ * This module contains all built-in synchronous assertion implementations
+ * including type checks, comparisons, equality tests, object satisfaction,
+ * function behavior validation, and property checks. Each assertion is
+ * implemented with proper error handling and type safety.
+ *
+ * @groupDescription Assertion Collections
+ * Collections of individual assertions. For those building on top of <span class="bupkis">BUPKIS</span>.
+ *
+ * @packageDocumentation
+ * @showGroups
+ */
+/**
+ * Tuple of all built-in date-related synchronous assertions.
+ *
+ * @group Assertion Collections
+ */
+export declare const SyncDateAssertions: readonly [import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "to be after", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>], (subject: string | number | Date, other: string | number | Date) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: undefined;
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"to be after">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "to be before", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>], (subject: string | number | Date, other: string | number | Date) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: undefined;
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"to be before">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "to be between", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "and", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>], (subject: string | number | Date, start: string | number | Date, end: string | number | Date) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: undefined;
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"to be between">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"and">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "to equal", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "within", import("zod").ZodCustomStringFormat<"duration">], (subject: string | number | Date, other: string | number | Date, toleranceStr: string) => {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: {
+        difference: number;
+    };
+    expected: {
+        maxDifference: number;
+    };
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"to equal">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"within">, import("zod").ZodCustomStringFormat<"duration">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "to be the same date as", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>], (subject: string | number | Date, other: string | number | Date) => {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"to be the same date as">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]], import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be a weekday"], (subject: unknown) => {
+    message: string;
+} | undefined, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be a weekend"], (subject: unknown) => {
+    message: string;
+} | undefined, never>];
+/**
+ * Tuple of all built-in esoteric synchronous assertions.
+ *
+ * @group Assertion Collections
+ */
+export declare const SyncEsotericAssertions: readonly [import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]], import("zod").ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be frozen"], (subject: unknown) => {
+    actual: boolean;
+    expected: boolean;
+    message: string;
+} | undefined, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, "to be an enumerable property of", import("zod").ZodNonOptional<import("zod").ZodUnknown>], (subject: string | number | symbol, obj: unknown) => {
+    actual: boolean;
+    expected: boolean;
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("../assertion-types.js").PhraseLiteralSlot<"to be an enumerable property of">, import("zod").ZodNonOptional<import("zod").ZodUnknown>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNonOptional<import("zod").ZodUnknown>, "to have enumerable property", import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => import("zod").ZodCustom<unknown, unknown>, readonly [import("zod").ZodNonOptional<import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have enumerable property">, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be sealed"], import("zod").ZodUnknown, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be extensible"], import("zod").ZodUnknown, never>];
+/**
+ * Tuple of all built-in basic synchronous assertions.
+ *
+ * @group Assertion Collections
+ */
+export declare const SyncBasicAssertions: readonly [import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an array", "to be array"]], import("zod").ZodArray<import("zod").ZodUnknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be an async function"], import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], import("zod").ZodBigInt, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], import("zod").ZodBoolean, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]], import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], import("zod").ZodDate, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be defined"], import("zod").ZodNonOptional<import("zod").ZodUnknown>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<ArrayLike<unknown>, ArrayLike<unknown>>, "to be empty"], (subject: ArrayLike<unknown>) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<ArrayLike<unknown>, ArrayLike<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("zod").ZodUnknown>, "to be empty"], import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("zod").ZodUnknown>, readonly [import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod").ZodString, "to be empty"], import("zod").ZodString, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]], import("zod").ZodCustom<Error, Error>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be false"], import("zod").ZodLiteral<false>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be falsy"], import("zod").ZodNullable<import("zod").ZodAny>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a function"], import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be infinite"], import("zod").ZodUnion<[import("zod").ZodLiteral<number>, import("zod").ZodLiteral<number>]>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]], import("zod").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be NaN"], import("zod").ZodNaN, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], import("zod").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be -Infinity"], import("zod").ZodLiteral<number>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], import("zod").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod").ZodString, "to be non-empty"], import("zod").ZodString, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be null"], import("zod").ZodNull, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a number", "to be finite"]], import("zod").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be an object"], import("zod").ZodNonOptional<import("zod").ZodUnknown> & import("zod").ZodType<object, unknown, import("zod/v4/core").$ZodTypeInternals<object, unknown>>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], import("zod").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be Infinity"], import("zod").ZodLiteral<number>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], import("zod").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a primitive"], import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodBigInt, import("zod").ZodSymbol, import("zod").ZodNull, import("zod").ZodUndefined]>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("zod").ZodUnknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], import("zod").ZodCustom<RegExp, RegExp>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a Set"], import("zod").ZodCustom<Set<unknown>, Set<unknown>>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a string"], import("zod").ZodString, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], import("zod").ZodSymbol, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be true"], import("zod").ZodLiteral<true>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], import("zod").ZodNonOptional<import("zod").ZodAny>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be undefined"], import("zod").ZodUndefined, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a WeakMap"], import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a WeakSet"], import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, never>];
+/**
+ * Tuple of all built-in parametric synchronous assertions.
+ *
+ * @group Assertion Collections
+ */
+export declare const SyncParametricAssertions: readonly [import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a", "to be an"], import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (_: unknown, ctor: import("../../types.js").Constructor) => import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnknown, readonly ["to be a", "to be an", "to have type"], import("zod").ZodEnum<{
+    [x: string]: string;
+}>], (_: unknown, type: string) => import("zod").ZodString | import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>> | import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | import("zod").ZodNumber | import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | import("zod").ZodArray<import("zod").ZodUnknown> | import("zod").ZodSymbol | import("zod").ZodCustom<RegExp, RegExp> | import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown> | import("zod").ZodBigInt | import("zod").ZodBoolean | import("zod").ZodDate | import("zod").ZodCustom<Error, Error> | import("zod").ZodNull | import("zod").ZodUndefined | import("zod").ZodObject<{}, import("zod/v4/core").$loose> | import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | import("zod").ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>, readonly [import("zod").ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, import("zod").ZodEnum<{
+    [x: string]: string;
+}>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, "to be greater than", import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("../assertion-types.js").PhraseLiteralSlot<"to be greater than">, import("zod").ZodNumber]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be less than", "to be lt"], import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be less than", "to be lt"]>, import("zod").ZodNumber]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be greater than or equal to", "to be at least", "to be gte"], import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be greater than or equal to", "to be at least", "to be gte"]>, import("zod").ZodNumber]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be less than or equal to", "to be at most", "to be lte"], import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be less than or equal to", "to be at most", "to be lte"]>, import("zod").ZodNumber]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be within", "to be between"], import("zod").ZodNumber, import("zod").ZodNumber], (subject: number, min: number, max: number) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodNumber, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>, import("zod").ZodNumber, import("zod").ZodNumber]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, "to be close to", import("zod").ZodNumber, import("zod").ZodOptional<import("zod").ZodNumber>], (subject: number, expected: number, tolerance?: number | undefined) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodNumber, import("../assertion-types.js").PhraseLiteralSlot<"to be close to">, import("zod").ZodNumber, import("zod").ZodOptional<import("zod").ZodNumber>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to be greater than", import("zod").ZodString], (subject: string, other: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be greater than">, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to be less than", import("zod").ZodString], (subject: string, other: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be less than">, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to be greater than or equal to", import("zod").ZodString], (subject: string, other: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be greater than or equal to">, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to be less than or equal to", import("zod").ZodString], (subject: string, other: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be less than or equal to">, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, readonly ["to begin with", "to start with"], import("zod").ZodString], (subject: string, prefix: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to end with", import("zod").ZodString], (subject: string, suffix: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to end with">, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be one of", import("zod").ZodArray<import("zod").ZodUnknown>], (subject: unknown, values: unknown[]) => {
+    actual: unknown;
+    expected: unknown[];
+    message: string;
+} | undefined, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", import("zod").ZodInt], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have arity">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Error, Error>, "to have message", import("zod").ZodString], (subject: Error, expectedMessage: string) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Error, Error>, import("../assertion-types.js").PhraseLiteralSlot<"to have message">, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Error, Error>, "to have message matching", import("zod").ZodCustom<RegExp, RegExp>], (subject: Error, pattern: RegExp) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Error, Error>, import("../assertion-types.js").PhraseLiteralSlot<"to have message matching">, import("zod").ZodCustom<RegExp, RegExp>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal", "is strictly equal to"], import("zod").ZodUnknown], (subject: unknown, value: unknown) => {
+    actual: unknown;
+    expected: unknown;
+    message: string;
+} | undefined, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to deep equal", "to deeply equal"], import("zod").ZodUnknown], (_: unknown, expected: unknown) => import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").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 [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralSlot<"to throw">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("../../types.js").Constructor) => {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw", "to throw error satisfying"], import("zod").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: {} | null;
+    message?: undefined;
+}, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw", "to throw error satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, "satisfying", import("zod").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("../../types.js").Constructor, param: unknown) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: undefined;
+}, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, import("../assertion-types.js").PhraseLiteralSlot<"satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, readonly ["includes", "contains", "to include", "to contain"], import("zod").ZodString], (subject: string, expected: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to have length", import("zod").ZodInt], (subject: string, expectedLength: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to have length">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to match", import("zod").ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to match">, import("zod").ZodCustom<RegExp, RegExp>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to satisfy", "to be like", "satisfies"], import("zod").ZodUnknown], (_subject: unknown, shape: unknown) => import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>, never>];
+/**
+ * @group Assertion Collections
+ */
+export declare const SyncCollectionAssertions: readonly [import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, readonly ["to contain", "to include"], import("zod").ZodUnknown], (subject: Map<unknown, unknown> | WeakMap<WeakKey, unknown>, key: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", import("zod").ZodInt], (_subject: Map<unknown, unknown>, expectedSize: number) => import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], import("zod").ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have size", import("zod").ZodInt], (_subject: Set<unknown>, expectedSize: number) => import("zod").ZodSet<import("zod").ZodUnknown>, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], import("zod").ZodCustom<Set<unknown>, Set<unknown>>, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, readonly ["to contain", "to include"], import("zod").ZodUnknown], (subject: unknown[], value: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, readonly ["to have item satisfying", "to have an item satisfying", "to contain item satisfying"], import("zod").ZodUnknown], (subject: unknown[], shape: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have item satisfying", "to have an item satisfying", "to contain item satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, readonly ["to have length", "to have size"], import("zod").ZodInt], (_subject: unknown[], expectedSize: number) => import("zod").ZodArray<import("zod").ZodUnknown>, readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>, import("zod").ZodInt]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, "to be non-empty"], import("zod").ZodArray<import("zod").ZodUnknown>, readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"], import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>>], (_subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: (string | number | symbol)[]) => import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"]>, import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("zod").ZodUnknown>, "to have size", import("zod").ZodInt], (subject: Record<string | number | symbol, unknown>, expectedSize: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have exact key", "to have exact property", "to have exact prop"], import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>], (_: Record<PropertyKey, unknown> | ((...args: any[]) => any), key: string | number | symbol) => import("zod").ZodPipe<import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("zod").ZodTransform<{}, Record<PropertyKey, unknown> | ((...args: any[]) => any)>>, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have exact key", "to have exact property", "to have exact prop"]>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have key", "to have property", "to have prop", "to contain key", "to contain property", "to contain prop", "to include key", "to include property", "to include prop"], import("zod").ZodType<string, unknown, import("zod/v4/core").$ZodTypeInternals<string, unknown>>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keypath: string) => {
+    actual: string;
+    expect: string;
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have key", "to have property", "to have prop", "to contain key", "to contain property", "to contain prop", "to include key", "to include property", "to include prop"]>, import("zod").ZodType<string, unknown, import("zod/v4/core").$ZodTypeInternals<string, unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to equal", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (actual: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to equal">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be a subset of", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (subset: Set<unknown>, superset: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be a subset of">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be a superset of", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (superset: Set<unknown>, subset: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be a superset of">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to intersect with", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to intersect with">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be disjoint from", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be disjoint from">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have union", import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "equal to", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have union">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have intersection", import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "equal to", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have intersection">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have difference", import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "equal to", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have difference">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have symmetric difference", import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "equal to", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have symmetric difference">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have key", import("zod").ZodUnknown], (map: Map<unknown, unknown>, key: unknown) => {
+    actual: unknown[];
+    expected: unknown[];
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have key">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have value", "to contain value", "to include value"], import("zod").ZodUnknown], (map: Map<unknown, unknown>, value: unknown) => {
+    actual: unknown[];
+    expected: unknown;
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have value", "to contain value", "to include value"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, readonly ["to have entry", "to have key/value pair", "to contain entry", "to contain key/value pair", "to include entry", "to include key/value pair"], import("zod").ZodTuple<[import("zod").ZodUnknown, import("zod").ZodUnknown], null>], (map: Map<unknown, unknown> | WeakMap<WeakKey, unknown>, [key, value]: [unknown, unknown]) => {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: unknown[] | undefined;
+    expected: unknown[];
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have entry", "to have key/value pair", "to contain entry", "to contain key/value pair", "to include entry", "to include key/value pair"]>, import("zod").ZodTuple<[import("zod").ZodUnknown, import("zod").ZodUnknown], null>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to equal", import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>], (mapA: Map<unknown, unknown>, mapB: Map<unknown, unknown>) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: unknown[];
+    expected: unknown[];
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to equal">, import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size greater than", import("zod").ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, minSize: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size greater than">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size less than", import("zod").ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, maxSize: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size less than">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size between", import("zod").ZodTuple<[import("zod").ZodInt, import("zod").ZodInt], null>], (collection: Map<unknown, unknown> | Set<unknown>, [min, max]: [number, number]) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size between">, import("zod").ZodTuple<[import("zod").ZodInt, import("zod").ZodInt], null>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, readonly ["to have values satisfying", "to contain values satisfying"], import("zod").ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have values satisfying", "to contain values satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, "to have values exhaustively satisfying", import("zod").ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have values exhaustively satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, readonly ["to have a value satisfying", "to have value satisfying", "to contain a value satisfying"], import("zod").ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a value satisfying", "to have value satisfying", "to contain a value satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, readonly ["to have a value exhaustively satisfying", "to have value exhaustively satisfying"], import("zod").ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a value exhaustively satisfying", "to have value exhaustively satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have keys satisfying", "to have props satisfying", "to have properties satisfying", "to have fields satisfying", "to contain keys satisfying", "to contain props satisfying", "to contain properties satisfying", "to contain fields satisfying"], import("zod").ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys satisfying", "to have props satisfying", "to have properties satisfying", "to have fields satisfying", "to contain keys satisfying", "to contain props satisfying", "to contain properties satisfying", "to contain fields satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have keys exhaustively satisfying", "to have props exhaustively satisfying", "to have properties exhaustively satisfying", "to have fields exhaustively satisfying"], import("zod").ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys exhaustively satisfying", "to have props exhaustively satisfying", "to have properties exhaustively satisfying", "to have fields exhaustively satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have a key satisfying", "to have key satisfying", "to have a prop satisfying", "to have prop satisfying", "to have a property satisfying", "to have property satisfying", "to have a field satisfying", "to have field satisfying"], import("zod").ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a key satisfying", "to have key satisfying", "to have a prop satisfying", "to have prop satisfying", "to have a property satisfying", "to have property satisfying", "to have a field satisfying", "to have field satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have a key exhaustively satisfying", "to have key exhaustively satisfying", "to have a prop exhaustively satisfying", "to have prop exhaustively satisfying", "to have a property exhaustively satisfying", "to have property exhaustively satisfying", "to have a field exhaustively satisfying", "to have field exhaustively satisfying"], import("zod").ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a key exhaustively satisfying", "to have key exhaustively satisfying", "to have a prop exhaustively satisfying", "to have prop exhaustively satisfying", "to have a property exhaustively satisfying", "to have property exhaustively satisfying", "to have a field exhaustively satisfying", "to have field exhaustively satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys satisfying", "to have props satisfying", "to have properties satisfying", "to have fields satisfying"], import("zod").ZodUnknown], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys satisfying", "to have props satisfying", "to have properties satisfying", "to have fields satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have a key satisfying", "to have key satisfying", "to have a prop satisfying", "to have prop satisfying", "to have a property satisfying", "to have property satisfying", "to have a field satisfying", "to have field satisfying"], import("zod").ZodUnknown], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a key satisfying", "to have key satisfying", "to have a prop satisfying", "to have prop satisfying", "to have a property satisfying", "to have property satisfying", "to have a field satisfying", "to have field satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys matching", "to have props matching", "to have properties matching", "to have fields matching"], import("zod").ZodCustom<RegExp, RegExp>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), pattern: RegExp) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys matching", "to have props matching", "to have properties matching", "to have fields matching"]>, import("zod").ZodCustom<RegExp, RegExp>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have a key matching", "to have key matching", "to have a prop matching", "to have prop matching", "to have a property matching", "to have property matching", "to have a field matching", "to have field matching"], import("zod").ZodCustom<RegExp, RegExp>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), pattern: RegExp) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a key matching", "to have key matching", "to have a prop matching", "to have prop matching", "to have a property matching", "to have property matching", "to have a field matching", "to have field matching"]>, import("zod").ZodCustom<RegExp, RegExp>]>];
+/**
+ * Tuple of snapshot-related synchronous assertions.
+ *
+ * @group Assertion Collections
+ */
+export declare const SyncSnapshotAssertions: readonly [import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnknown, readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"], import("zod").ZodNonOptional<import("zod").ZodUnknown>], (actual: unknown, context: unknown) => void | import("../assertion-types.js").AssertionFailure, readonly [import("zod").ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"]>, import("zod").ZodNonOptional<import("zod").ZodUnknown>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnknown, readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"], import("zod").ZodNonOptional<import("zod").ZodUnknown>, "with options", import("zod").ZodObject<{
+    hint: import("zod").ZodOptional<import("zod").ZodString>;
+    serializer: import("zod").ZodOptional<import("zod").ZodAny>;
+}, import("zod/v4/core").$strip>], (actual: unknown, context: unknown, options: {
+    hint?: string | undefined;
+    serializer?: any;
+}) => void | import("../assertion-types.js").AssertionFailure, readonly [import("zod").ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"]>, import("zod").ZodNonOptional<import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"with options">, import("zod").ZodObject<{
+    hint: import("zod").ZodOptional<import("zod").ZodString>;
+    serializer: import("zod").ZodOptional<import("zod").ZodAny>;
+}, import("zod/v4/core").$strip>]>];
+/**
+ * Tuple of all built-in synchronous assertions.
+ *
+ * @group Assertion Collections
+ */
+export declare const SyncAssertions: readonly [import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, readonly ["to contain", "to include"], import("zod").ZodUnknown], (subject: Map<unknown, unknown> | WeakMap<WeakKey, unknown>, key: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", import("zod").ZodInt], (_subject: Map<unknown, unknown>, expectedSize: number) => import("zod").ZodMap<import("zod").ZodUnknown, import("zod").ZodUnknown>, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], import("zod").ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have size", import("zod").ZodInt], (_subject: Set<unknown>, expectedSize: number) => import("zod").ZodSet<import("zod").ZodUnknown>, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], import("zod").ZodCustom<Set<unknown>, Set<unknown>>, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, readonly ["to contain", "to include"], import("zod").ZodUnknown], (subject: unknown[], value: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, readonly ["to have item satisfying", "to have an item satisfying", "to contain item satisfying"], import("zod").ZodUnknown], (subject: unknown[], shape: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have item satisfying", "to have an item satisfying", "to contain item satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, readonly ["to have length", "to have size"], import("zod").ZodInt], (_subject: unknown[], expectedSize: number) => import("zod").ZodArray<import("zod").ZodUnknown>, readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>, import("zod").ZodInt]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod").ZodArray<import("zod").ZodUnknown>, "to be non-empty"], import("zod").ZodArray<import("zod").ZodUnknown>, readonly [import("zod").ZodArray<import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"], import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>>], (_subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: (string | number | symbol)[]) => import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"]>, import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("zod").ZodUnknown>, "to have size", import("zod").ZodInt], (subject: Record<string | number | symbol, unknown>, expectedSize: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have exact key", "to have exact property", "to have exact prop"], import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>], (_: Record<PropertyKey, unknown> | ((...args: any[]) => any), key: string | number | symbol) => import("zod").ZodPipe<import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("zod").ZodTransform<{}, Record<PropertyKey, unknown> | ((...args: any[]) => any)>>, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have exact key", "to have exact property", "to have exact prop"]>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have key", "to have property", "to have prop", "to contain key", "to contain property", "to contain prop", "to include key", "to include property", "to include prop"], import("zod").ZodType<string, unknown, import("zod/v4/core").$ZodTypeInternals<string, unknown>>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keypath: string) => {
+    actual: string;
+    expect: string;
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have key", "to have property", "to have prop", "to contain key", "to contain property", "to contain prop", "to include key", "to include property", "to include prop"]>, import("zod").ZodType<string, unknown, import("zod/v4/core").$ZodTypeInternals<string, unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to equal", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (actual: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to equal">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be a subset of", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (subset: Set<unknown>, superset: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be a subset of">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be a superset of", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (superset: Set<unknown>, subset: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be a superset of">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to intersect with", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to intersect with">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be disjoint from", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be disjoint from">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have union", import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "equal to", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have union">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have intersection", import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "equal to", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have intersection">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have difference", import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "equal to", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have difference">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have symmetric difference", import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "equal to", import("zod").ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have symmetric difference">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"equal to">, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have key", import("zod").ZodUnknown], (map: Map<unknown, unknown>, key: unknown) => {
+    actual: unknown[];
+    expected: unknown[];
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have key">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have value", "to contain value", "to include value"], import("zod").ZodUnknown], (map: Map<unknown, unknown>, value: unknown) => {
+    actual: unknown[];
+    expected: unknown;
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have value", "to contain value", "to include value"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, readonly ["to have entry", "to have key/value pair", "to contain entry", "to contain key/value pair", "to include entry", "to include key/value pair"], import("zod").ZodTuple<[import("zod").ZodUnknown, import("zod").ZodUnknown], null>], (map: Map<unknown, unknown> | WeakMap<WeakKey, unknown>, [key, value]: [unknown, unknown]) => {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: unknown[] | undefined;
+    expected: unknown[];
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<[import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have entry", "to have key/value pair", "to contain entry", "to contain key/value pair", "to include entry", "to include key/value pair"]>, import("zod").ZodTuple<[import("zod").ZodUnknown, import("zod").ZodUnknown], null>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to equal", import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>], (mapA: Map<unknown, unknown>, mapB: Map<unknown, unknown>) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: unknown[];
+    expected: unknown[];
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to equal">, import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size greater than", import("zod").ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, minSize: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size greater than">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size less than", import("zod").ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, maxSize: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size less than">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size between", import("zod").ZodTuple<[import("zod").ZodInt, import("zod").ZodInt], null>], (collection: Map<unknown, unknown> | Set<unknown>, [min, max]: [number, number]) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size between">, import("zod").ZodTuple<[import("zod").ZodInt, import("zod").ZodInt], null>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, readonly ["to have values satisfying", "to contain values satisfying"], import("zod").ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have values satisfying", "to contain values satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, "to have values exhaustively satisfying", import("zod").ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have values exhaustively satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, readonly ["to have a value satisfying", "to have value satisfying", "to contain a value satisfying"], import("zod").ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a value satisfying", "to have value satisfying", "to contain a value satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, readonly ["to have a value exhaustively satisfying", "to have value exhaustively satisfying"], import("zod").ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("zod").ZodArray<import("zod").ZodUnknown>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a value exhaustively satisfying", "to have value exhaustively satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have keys satisfying", "to have props satisfying", "to have properties satisfying", "to have fields satisfying", "to contain keys satisfying", "to contain props satisfying", "to contain properties satisfying", "to contain fields satisfying"], import("zod").ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys satisfying", "to have props satisfying", "to have properties satisfying", "to have fields satisfying", "to contain keys satisfying", "to contain props satisfying", "to contain properties satisfying", "to contain fields satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have keys exhaustively satisfying", "to have props exhaustively satisfying", "to have properties exhaustively satisfying", "to have fields exhaustively satisfying"], import("zod").ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys exhaustively satisfying", "to have props exhaustively satisfying", "to have properties exhaustively satisfying", "to have fields exhaustively satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have a key satisfying", "to have key satisfying", "to have a prop satisfying", "to have prop satisfying", "to have a property satisfying", "to have property satisfying", "to have a field satisfying", "to have field satisfying"], import("zod").ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a key satisfying", "to have key satisfying", "to have a prop satisfying", "to have prop satisfying", "to have a property satisfying", "to have property satisfying", "to have a field satisfying", "to have field satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have a key exhaustively satisfying", "to have key exhaustively satisfying", "to have a prop exhaustively satisfying", "to have prop exhaustively satisfying", "to have a property exhaustively satisfying", "to have property exhaustively satisfying", "to have a field exhaustively satisfying", "to have field exhaustively satisfying"], import("zod").ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a key exhaustively satisfying", "to have key exhaustively satisfying", "to have a prop exhaustively satisfying", "to have prop exhaustively satisfying", "to have a property exhaustively satisfying", "to have property exhaustively satisfying", "to have a field exhaustively satisfying", "to have field exhaustively satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys satisfying", "to have props satisfying", "to have properties satisfying", "to have fields satisfying"], import("zod").ZodUnknown], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys satisfying", "to have props satisfying", "to have properties satisfying", "to have fields satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have a key satisfying", "to have key satisfying", "to have a prop satisfying", "to have prop satisfying", "to have a property satisfying", "to have property satisfying", "to have a field satisfying", "to have field satisfying"], import("zod").ZodUnknown], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a key satisfying", "to have key satisfying", "to have a prop satisfying", "to have prop satisfying", "to have a property satisfying", "to have property satisfying", "to have a field satisfying", "to have field satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys matching", "to have props matching", "to have properties matching", "to have fields matching"], import("zod").ZodCustom<RegExp, RegExp>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), pattern: RegExp) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys matching", "to have props matching", "to have properties matching", "to have fields matching"]>, import("zod").ZodCustom<RegExp, RegExp>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have a key matching", "to have key matching", "to have a prop matching", "to have prop matching", "to have a property matching", "to have property matching", "to have a field matching", "to have field matching"], import("zod").ZodCustom<RegExp, RegExp>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), pattern: RegExp) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have a key matching", "to have key matching", "to have a prop matching", "to have prop matching", "to have a property matching", "to have property matching", "to have a field matching", "to have field matching"]>, import("zod").ZodCustom<RegExp, RegExp>]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an array", "to be array"]], import("zod").ZodArray<import("zod").ZodUnknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be an async function"], import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], import("zod").ZodBigInt, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], import("zod").ZodBoolean, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]], import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], import("zod").ZodDate, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be defined"], import("zod").ZodNonOptional<import("zod").ZodUnknown>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<ArrayLike<unknown>, ArrayLike<unknown>>, "to be empty"], (subject: ArrayLike<unknown>) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<ArrayLike<unknown>, ArrayLike<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("zod").ZodUnknown>, "to be empty"], import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("zod").ZodUnknown>, readonly [import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod").ZodString, "to be empty"], import("zod").ZodString, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]], import("zod").ZodCustom<Error, Error>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be false"], import("zod").ZodLiteral<false>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be falsy"], import("zod").ZodNullable<import("zod").ZodAny>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a function"], import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be infinite"], import("zod").ZodUnion<[import("zod").ZodLiteral<number>, import("zod").ZodLiteral<number>]>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]], import("zod").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be NaN"], import("zod").ZodNaN, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], import("zod").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be -Infinity"], import("zod").ZodLiteral<number>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], import("zod").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod").ZodString, "to be non-empty"], import("zod").ZodString, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be null"], import("zod").ZodNull, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a number", "to be finite"]], import("zod").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be an object"], import("zod").ZodNonOptional<import("zod").ZodUnknown> & import("zod").ZodType<object, unknown, import("zod/v4/core").$ZodTypeInternals<object, unknown>>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], import("zod").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be Infinity"], import("zod").ZodLiteral<number>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], import("zod").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a primitive"], import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodBigInt, import("zod").ZodSymbol, import("zod").ZodNull, import("zod").ZodUndefined]>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], import("zod").ZodRecord<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("zod").ZodUnknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], import("zod").ZodCustom<RegExp, RegExp>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a Set"], import("zod").ZodCustom<Set<unknown>, Set<unknown>>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a string"], import("zod").ZodString, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], import("zod").ZodSymbol, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be true"], import("zod").ZodLiteral<true>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], import("zod").ZodNonOptional<import("zod").ZodAny>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be undefined"], import("zod").ZodUndefined, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a WeakMap"], import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a WeakSet"], import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a", "to be an"], import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (_: unknown, ctor: import("../../types.js").Constructor) => import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnknown, readonly ["to be a", "to be an", "to have type"], import("zod").ZodEnum<{
+    [x: string]: string;
+}>], (_: unknown, type: string) => import("zod").ZodString | import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>> | import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | import("zod").ZodNumber | import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | import("zod").ZodArray<import("zod").ZodUnknown> | import("zod").ZodSymbol | import("zod").ZodCustom<RegExp, RegExp> | import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown> | import("zod").ZodBigInt | import("zod").ZodBoolean | import("zod").ZodDate | import("zod").ZodCustom<Error, Error> | import("zod").ZodNull | import("zod").ZodUndefined | import("zod").ZodObject<{}, import("zod/v4/core").$loose> | import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | import("zod").ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>, readonly [import("zod").ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, import("zod").ZodEnum<{
+    [x: string]: string;
+}>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, "to be greater than", import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("../assertion-types.js").PhraseLiteralSlot<"to be greater than">, import("zod").ZodNumber]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be less than", "to be lt"], import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be less than", "to be lt"]>, import("zod").ZodNumber]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be greater than or equal to", "to be at least", "to be gte"], import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be greater than or equal to", "to be at least", "to be gte"]>, import("zod").ZodNumber]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be less than or equal to", "to be at most", "to be lte"], import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be less than or equal to", "to be at most", "to be lte"]>, import("zod").ZodNumber]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be within", "to be between"], import("zod").ZodNumber, import("zod").ZodNumber], (subject: number, min: number, max: number) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodNumber, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>, import("zod").ZodNumber, import("zod").ZodNumber]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, "to be close to", import("zod").ZodNumber, import("zod").ZodOptional<import("zod").ZodNumber>], (subject: number, expected: number, tolerance?: number | undefined) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodNumber, import("../assertion-types.js").PhraseLiteralSlot<"to be close to">, import("zod").ZodNumber, import("zod").ZodOptional<import("zod").ZodNumber>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to be greater than", import("zod").ZodString], (subject: string, other: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be greater than">, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to be less than", import("zod").ZodString], (subject: string, other: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be less than">, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to be greater than or equal to", import("zod").ZodString], (subject: string, other: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be greater than or equal to">, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to be less than or equal to", import("zod").ZodString], (subject: string, other: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be less than or equal to">, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, readonly ["to begin with", "to start with"], import("zod").ZodString], (subject: string, prefix: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to end with", import("zod").ZodString], (subject: string, suffix: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to end with">, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be one of", import("zod").ZodArray<import("zod").ZodUnknown>], (subject: unknown, values: unknown[]) => {
+    actual: unknown;
+    expected: unknown[];
+    message: string;
+} | undefined, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", import("zod").ZodInt], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have arity">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Error, Error>, "to have message", import("zod").ZodString], (subject: Error, expectedMessage: string) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Error, Error>, import("../assertion-types.js").PhraseLiteralSlot<"to have message">, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Error, Error>, "to have message matching", import("zod").ZodCustom<RegExp, RegExp>], (subject: Error, pattern: RegExp) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<Error, Error>, import("../assertion-types.js").PhraseLiteralSlot<"to have message matching">, import("zod").ZodCustom<RegExp, RegExp>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal", "is strictly equal to"], import("zod").ZodUnknown], (subject: unknown, value: unknown) => {
+    actual: unknown;
+    expected: unknown;
+    message: string;
+} | undefined, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to deep equal", "to deeply equal"], import("zod").ZodUnknown], (_: unknown, expected: unknown) => import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").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 [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralSlot<"to throw">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("../../types.js").Constructor) => {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw", "to throw error satisfying"], import("zod").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: {} | null;
+    message?: undefined;
+}, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw", "to throw error satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, "satisfying", import("zod").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("../../types.js").Constructor, param: unknown) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: undefined;
+}, readonly [import("zod").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, import("../assertion-types.js").PhraseLiteralSlot<"satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, readonly ["includes", "contains", "to include", "to contain"], import("zod").ZodString], (subject: string, expected: string) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, import("zod").ZodString]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to have length", import("zod").ZodInt], (subject: string, expectedLength: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to have length">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to match", import("zod").ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to match">, import("zod").ZodCustom<RegExp, RegExp>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to satisfy", "to be like", "satisfies"], import("zod").ZodUnknown], (_subject: unknown, shape: unknown) => import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]], import("zod").ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be frozen"], (subject: unknown) => {
+    actual: boolean;
+    expected: boolean;
+    message: string;
+} | undefined, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, "to be an enumerable property of", import("zod").ZodNonOptional<import("zod").ZodUnknown>], (subject: string | number | symbol, obj: unknown) => {
+    actual: boolean;
+    expected: boolean;
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("../assertion-types.js").PhraseLiteralSlot<"to be an enumerable property of">, import("zod").ZodNonOptional<import("zod").ZodUnknown>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNonOptional<import("zod").ZodUnknown>, "to have enumerable property", import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => import("zod").ZodCustom<unknown, unknown>, readonly [import("zod").ZodNonOptional<import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have enumerable property">, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be sealed"], import("zod").ZodUnknown, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be extensible"], import("zod").ZodUnknown, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "to be after", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>], (subject: string | number | Date, other: string | number | Date) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: undefined;
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"to be after">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "to be before", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>], (subject: string | number | Date, other: string | number | Date) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: undefined;
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"to be before">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "to be between", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "and", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>], (subject: string | number | Date, start: string | number | Date, end: string | number | Date) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: import("zod").ZodDate;
+    subject: Date;
+    message?: undefined;
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"to be between">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"and">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "to equal", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "within", import("zod").ZodCustomStringFormat<"duration">], (subject: string | number | Date, other: string | number | Date, toleranceStr: string) => {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: {
+        difference: number;
+    };
+    expected: {
+        maxDifference: number;
+    };
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"to equal">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"within">, import("zod").ZodCustomStringFormat<"duration">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, "to be the same date as", import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>], (subject: string | number | Date, other: string | number | Date) => {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, import("../assertion-types.js").PhraseLiteralSlot<"to be the same date as">, import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]], import("zod").ZodUnion<readonly [import("zod").ZodDate, import("zod").ZodUnion<readonly [import("zod").ZodISODateTime, import("zod").ZodISODate]>, import("zod").ZodInt]>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be a weekday"], (subject: unknown) => {
+    message: string;
+} | undefined, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be a weekend"], (subject: unknown) => {
+    message: string;
+} | undefined, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnknown, readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"], import("zod").ZodNonOptional<import("zod").ZodUnknown>], (actual: unknown, context: unknown) => void | import("../assertion-types.js").AssertionFailure, readonly [import("zod").ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"]>, import("zod").ZodNonOptional<import("zod").ZodUnknown>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnknown, readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"], import("zod").ZodNonOptional<import("zod").ZodUnknown>, "with options", import("zod").ZodObject<{
+    hint: import("zod").ZodOptional<import("zod").ZodString>;
+    serializer: import("zod").ZodOptional<import("zod").ZodAny>;
+}, import("zod/v4/core").$strip>], (actual: unknown, context: unknown, options: {
+    hint?: string | undefined;
+    serializer?: any;
+}) => void | import("../assertion-types.js").AssertionFailure, readonly [import("zod").ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"]>, import("zod").ZodNonOptional<import("zod").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"with options">, import("zod").ZodObject<{
+    hint: import("zod").ZodOptional<import("zod").ZodString>;
+    serializer: import("zod").ZodOptional<import("zod").ZodAny>;
+}, import("zod/v4/core").$strip>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, readonly ["to yield", "to emit", "to yield value satisfying"], import("zod").ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to yield", "to emit", "to yield value satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield value exhaustively satisfying", import("zod").ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield value exhaustively satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield items satisfying", import("zod").ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield items satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield items exhaustively satisfying", import("zod").ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield items exhaustively satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, readonly ["to yield first", "to yield first satisfying"], import("zod").ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to yield first", "to yield first satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield first exhaustively satisfying", import("zod").ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield first exhaustively satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, readonly ["to yield last", "to yield last satisfying"], import("zod").ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to yield last", "to yield last satisfying"]>, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield last exhaustively satisfying", import("zod").ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield last exhaustively satisfying">, import("zod").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield count", import("zod").ZodInt], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expectedCount: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield count">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield at least", import("zod").ZodInt], (subject: Iterator<unknown, any, any> | Iterable<unknown>, minCount: number) => {
+    actual: number;
+    expected: string;
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield at least">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield at most", import("zod").ZodInt], (subject: Iterator<unknown, any, any> | Iterable<unknown>, maxCount: number) => {
+    actual: number;
+    expected: string;
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield at most">, import("zod").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to be an empty iterable"], (subject: Iterator<unknown, any, any> | Iterable<unknown>) => {
+    message: string;
+} | undefined, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to be an empty iterable">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield exactly", import("zod").ZodArray<import("zod").ZodUnknown>], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown[]) => {
+    schema: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown[];
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to yield exactly">, import("zod").ZodArray<import("zod").ZodUnknown>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, readonly ["to yield sequence satisfying", "to yield array satisfying"], import("zod").ZodArray<import("zod").ZodUnknown>], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown[]) => {
+    schema: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+    subject: unknown[];
+}, readonly [import("zod").ZodUnion<readonly [import("zod").ZodCustom<Iterable<unknown>, Iterable<unknown>>, import("zod").ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to yield sequence satisfying", "to yield array satisfying"]>, import("zod").ZodArray<import("zod").ZodUnknown>]>];
+export * from "./snapshot.cjs";
+export * from "./sync-basic.cjs";
+export * from "./sync-collection.cjs";
+export * from "./sync-date.cjs";
+export * from "./sync-esoteric.cjs";
+export * from "./sync-iterable.cjs";
+export * from "./sync-parametric.cjs";
+//# sourceMappingURL=sync.d.ts.map