bupkis 0.18.1 → 0.18.2

package/dist/index.d.ts

@@ -1,448 +0,0 @@
-/**
- * Main entry point for the Bupkis assertion library.
- *
- * This module exports all public APIs including the main `expect` function,
- * asynchronous `expectAsync` function, assertion creation utilities, type
- * guards, schema definitions, utility functions, and error types.
- *
- * @module bupkis
- * @category API
- * @example
- *
- * ```ts
- * import { expect, expectAsync, z, createAssertion } from 'bupkis';
- * ```
- *
- * {@link https://zod.dev | Zod v4} is exported as `z` if you aren't already
- * using a {@link https://standardschema.dev | Standard Schema V1}-compatible
- * validation library.
- */
-import { z } from 'zod';
-export * as assertions from "./assertion/impl/index.js";
-export { expect, expectAsync } from "./bootstrap.js";
-/**
- * Re-export of `DiffOptions` type from jest-diff for use with custom assertion
- * diff configuration.
- *
- * @see {@link https://npm.im/jest-diff | jest-diff} for available options
- */
-export type { DiffOptions } from "./diff.js";
-export * from "./error.js";
-export * as schema from "./schema.js";
-/**
- * Re-export of snapshot testing types for convenient access.
- *
- * For full snapshot API, import from 'bupkis/snapshot'.
- */
-export type { SnapshotAdapter, SnapshotContext, SnapshotOptions, SnapshotSerializer, } from "./snapshot/adapter.js";
-/**
- * Re-export of {@link https://zod.dev Zod v4} for use in custom assertion
- * implementations.
- */
-export { z };
-/**
- * Re-export of Standard Schema v1 types for use in custom assertion
- * implementations.
- *
- * @see {@link https://standardschema.dev | Standard Schema Specification}
- */
-export type { StandardSchemaV1 } from "./standard-schema.js";
-/**
- * Re-export of most (all?) types defined within <span
- * class="bupkis">Bupkis</span>.
- *
- * @example
- *
- * ```ts
- * import { types } from 'bupkis';
- * ```
- */
-export type * as types from "./types.js";
-/**
- * @primaryExport
- */
-export type { AssertionFailure, AssertionStandardSchemaAsync, AssertionStandardSchemaSync, Bupkis, CreateAssertionFn, CreateAsyncAssertionFn, Expect, ExpectAsync, ExpectIt, ExpectItAsync, FailFn, Keypath, UseFn, } from "./types.js";
-export { createAssertion, createAsyncAssertion, fail, use };
-declare const 
-/**
- * The main factory function for creating asynchronous assertions.
- *
- * Exported from the entry point; is also a property of {@link Expect} and
- * {@link ExpectAsync}.
- *
- * @function
- * @primaryExport
- * @group Core API
- */
-createAssertion: import("./types.js").CreateAssertionFn, 
-/**
- * The main factory function for creating asynchronous assertions.
- *
- * Exported from the entry point; is also a property of {@link Expect} and
- * {@link ExpectAsync}.
- *
- * @function
- * @primaryExport
- * @group Core API
- */
-createAsyncAssertion: import("./types.js").CreateAsyncAssertionFn, 
-/**
- * {@inheritDoc FailFn}
- *
- * @function
- * @primaryExport
- * @group Core API
- */
-fail: import("./types.js").FailFn, 
-/**
- * {@inheritDoc UseFn}
- *
- * @function
- * @primaryExport
- * @group Core API
- */
-use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: Map<unknown, unknown> | WeakMap<WeakKey, unknown>, key: unknown) => {
-    message: string;
-    actual?: undefined;
-    expected?: undefined;
-} | {
-    actual: unknown;
-    expected: string;
-    message: string;
-} | undefined, readonly [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", z.ZodInt], (_subject: Map<unknown, unknown>, expectedSize: number) => z.ZodMap<z.ZodUnknown, z.ZodUnknown>, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => {
-    message: string;
-    actual?: undefined;
-    expected?: undefined;
-} | {
-    actual: unknown;
-    expected: string;
-    message: string;
-} | undefined, readonly [z.ZodUnion<[z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have size", z.ZodInt], (_subject: Set<unknown>, expectedSize: number) => z.ZodSet<z.ZodUnknown>, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], z.ZodCustom<Set<unknown>, Set<unknown>>, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: unknown[], value: unknown) => {
-    message: string;
-} | undefined, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, readonly ["to have item satisfying", "to have an item satisfying", "to contain item satisfying"], z.ZodUnknown], (subject: unknown[], shape: unknown) => {
-    message: string;
-} | undefined, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have item satisfying", "to have an item satisfying", "to contain item satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, readonly ["to have length", "to have size"], z.ZodInt], (_subject: unknown[], expectedSize: number) => z.ZodArray<z.ZodUnknown>, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>, z.ZodInt]>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"], z.ZodArray<z.ZodUnknown>, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.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"], z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>>], (_subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: (string | number | symbol)[]) => z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./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"]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, "to have size", z.ZodInt], (subject: Record<string | number | symbol, unknown>, expectedSize: number) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.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"], z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>], (_: Record<PropertyKey, unknown> | ((...args: any[]) => any), key: string | number | symbol) => z.ZodPipe<z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, z.ZodTransform<{}, Record<PropertyKey, unknown> | ((...args: any[]) => any)>>, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have exact key", "to have exact property", "to have exact prop"]>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>]>, import("./types.js").AssertionFunctionSync<readonly [z.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"], z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keypath: string) => {
-    actual: string;
-    expect: string;
-    message: string;
-} | undefined, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./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"]>, z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to equal", z.ZodCustom<Set<unknown>, Set<unknown>>], (actual: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to equal">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be a subset of", z.ZodCustom<Set<unknown>, Set<unknown>>], (subset: Set<unknown>, superset: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be a subset of">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be a superset of", z.ZodCustom<Set<unknown>, Set<unknown>>], (superset: Set<unknown>, subset: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be a superset of">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to intersect with", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to intersect with">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be disjoint from", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be disjoint from">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have union", z.ZodCustom<Set<unknown>, Set<unknown>>, "equal to", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have union">, z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"equal to">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have intersection", z.ZodCustom<Set<unknown>, Set<unknown>>, "equal to", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have intersection">, z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"equal to">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have difference", z.ZodCustom<Set<unknown>, Set<unknown>>, "equal to", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have difference">, z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"equal to">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have symmetric difference", z.ZodCustom<Set<unknown>, Set<unknown>>, "equal to", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have symmetric difference">, z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"equal to">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have key", z.ZodUnknown], (map: Map<unknown, unknown>, key: unknown) => {
-    actual: unknown[];
-    expected: unknown[];
-    message: string;
-} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have key">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have value", "to contain value", "to include value"], z.ZodUnknown], (map: Map<unknown, unknown>, value: unknown) => {
-    actual: unknown[];
-    expected: unknown;
-    message: string;
-} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have value", "to contain value", "to include value"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.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"], z.ZodTuple<[z.ZodUnknown, z.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 [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("./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"]>, z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to equal", z.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 [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to equal">, z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size greater than", z.ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, minSize: number) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to have size greater than">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size less than", z.ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, maxSize: number) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to have size less than">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size between", z.ZodTuple<[z.ZodInt, z.ZodInt], null>], (collection: Map<unknown, unknown> | Set<unknown>, [min, max]: [number, number]) => {
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to have size between">, z.ZodTuple<[z.ZodInt, z.ZodInt], null>]>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an array", "to be array"]], z.ZodArray<z.ZodUnknown>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be an async function"], z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], z.ZodBigInt, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], z.ZodBoolean, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], z.ZodDate, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be defined"], z.ZodNonOptional<z.ZodUnknown>, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<ArrayLike<unknown>, ArrayLike<unknown>>, "to be empty"], (subject: ArrayLike<unknown>) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [z.ZodCustom<ArrayLike<unknown>, ArrayLike<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, "to be empty"], z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodString, "to be empty"], z.ZodString, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]], z.ZodCustom<Error, Error>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be false"], z.ZodLiteral<false>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be falsy"], z.ZodNullable<z.ZodAny>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a function"], z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be infinite"], z.ZodUnion<[z.ZodLiteral<number>, z.ZodLiteral<number>]>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be NaN"], z.ZodNaN, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be -Infinity"], z.ZodLiteral<number>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodString, "to be non-empty"], z.ZodString, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be null"], z.ZodNull, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a number", "to be finite"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be an object"], z.ZodNonOptional<z.ZodUnknown> & z.ZodType<object, unknown, z.core.$ZodTypeInternals<object, unknown>>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be Infinity"], z.ZodLiteral<number>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a primitive"], z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodBigInt, z.ZodSymbol, z.ZodNull, z.ZodUndefined]>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], z.ZodCustom<RegExp, RegExp>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a Set"], z.ZodCustom<Set<unknown>, Set<unknown>>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a string"], z.ZodString, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], z.ZodSymbol, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be true"], z.ZodLiteral<true>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], z.ZodNonOptional<z.ZodAny>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be undefined"], z.ZodUndefined, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a WeakMap"], z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a WeakSet"], z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, never>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a", "to be an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (_: unknown, ctor: import("./types.js").Constructor) => z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnknown, readonly ["to be a", "to be an", "to have type"], z.ZodEnum<{
-    [x: string]: string;
-}>], (_: unknown, type: string) => z.ZodString | z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown> | z.ZodNumber | z.ZodSymbol | z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | z.ZodBoolean | z.ZodBigInt | z.ZodNull | z.ZodUndefined | z.ZodCustom<RegExp, RegExp> | z.ZodDate | z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | z.ZodArray<z.ZodUnknown> | z.ZodCustom<Error, Error> | z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>> | z.ZodObject<{}, z.core.$loose>, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, z.ZodEnum<{
-    [x: string]: string;
-}>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, "to be greater than", z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralSlot<"to be greater than">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be less than", "to be lt"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be less than", "to be lt"]>, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be greater than or equal to", "to be at least", "to be gte"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be greater than or equal to", "to be at least", "to be gte"]>, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be less than or equal to", "to be at most", "to be lte"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be less than or equal to", "to be at most", "to be lte"]>, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be within", "to be between"], z.ZodNumber, z.ZodNumber], (subject: number, min: number, max: number) => {
-    message: string;
-} | undefined, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>, z.ZodNumber, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, "to be close to", z.ZodNumber, z.ZodOptional<z.ZodNumber>], (subject: number, expected: number, tolerance?: number | undefined) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [z.ZodNumber, import("./types.js").PhraseLiteralSlot<"to be close to">, z.ZodNumber, z.ZodOptional<z.ZodNumber>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to be greater than", z.ZodString], (subject: string, other: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be greater than">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to be less than", z.ZodString], (subject: string, other: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be less than">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to be greater than or equal to", z.ZodString], (subject: string, other: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be greater than or equal to">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to be less than or equal to", z.ZodString], (subject: string, other: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be less than or equal to">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, readonly ["to begin with", "to start with"], z.ZodString], (subject: string, prefix: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to end with", z.ZodString], (subject: string, suffix: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to end with">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly ["to be one of", z.ZodArray<z.ZodUnknown>], (subject: unknown, values: unknown[]) => {
-    actual: unknown;
-    expected: unknown[];
-    message: string;
-} | undefined, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", z.ZodInt], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to have arity">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Error, Error>, "to have message", z.ZodString], (subject: Error, expectedMessage: string) => {
-    actual: string;
-    expected: string;
-    message: string;
-} | undefined, readonly [z.ZodCustom<Error, Error>, import("./types.js").PhraseLiteralSlot<"to have message">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Error, Error>, "to have message matching", z.ZodCustom<RegExp, RegExp>], (subject: Error, pattern: RegExp) => {
-    message: string;
-} | undefined, readonly [z.ZodCustom<Error, Error>, import("./types.js").PhraseLiteralSlot<"to have message matching">, z.ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal", "is strictly equal to"], z.ZodUnknown], (subject: unknown, value: unknown) => {
-    actual: unknown;
-    expected: unknown;
-    message: string;
-} | undefined, never>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to deep equal", "to deeply equal"], z.ZodUnknown], (_: unknown, expected: unknown) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to throw"], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => {
-    message: string;
-} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to throw">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], z.ZodCustom<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 [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw", "to throw error satisfying"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => {
-    message: string;
-    schema?: undefined;
-    subject?: undefined;
-} | {
-    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-    subject: {} | null;
-    message?: undefined;
-}, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw", "to throw error satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, "satisfying", z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor, param: unknown) => {
-    message: string;
-    schema?: undefined;
-    subject?: undefined;
-} | {
-    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-    subject: {} | null;
-    message?: undefined;
-}, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, import("./types.js").PhraseLiteralSlot<"satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, readonly ["includes", "contains", "to include", "to contain"], z.ZodString], (subject: string, expected: string) => {
-    message: string;
-} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to have length", z.ZodInt], (subject: string, expectedLength: number) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to have length">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to match", z.ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to match">, z.ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to satisfy", "to be like", "satisfies"], z.ZodUnknown], (_subject: unknown, shape: unknown) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]], z.ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>, never>, import("./types.js").AssertionFunctionSync<readonly ["to be frozen"], (subject: unknown) => {
-    actual: boolean;
-    expected: boolean;
-    message: string;
-} | undefined, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, "to be an enumerable property of", z.ZodNonOptional<z.ZodUnknown>], (subject: string | number | symbol, obj: unknown) => {
-    actual: boolean;
-    expected: boolean;
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, import("./types.js").PhraseLiteralSlot<"to be an enumerable property of">, z.ZodNonOptional<z.ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNonOptional<z.ZodUnknown>, "to have enumerable property", z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => z.ZodCustom<unknown, unknown>, readonly [z.ZodNonOptional<z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have enumerable property">, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>]>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be sealed"], z.ZodUnknown, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be extensible"], z.ZodUnknown, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "to be after", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>], (subject: string | number | Date, other: string | number | Date) => {
-    message: string;
-    schema?: undefined;
-    subject?: undefined;
-} | {
-    schema: z.ZodDate;
-    subject: Date;
-    message?: undefined;
-}, readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"to be after">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "to be before", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>], (subject: string | number | Date, other: string | number | Date) => {
-    message: string;
-    schema?: undefined;
-    subject?: undefined;
-} | {
-    schema: z.ZodDate;
-    subject: Date;
-    message?: undefined;
-}, readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"to be before">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "to be between", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "and", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>], (subject: string | number | Date, start: string | number | Date, end: string | number | Date) => {
-    message: string;
-    schema?: undefined;
-    subject?: undefined;
-} | {
-    schema: z.ZodDate;
-    subject: Date;
-    message?: undefined;
-}, readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"to be between">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"and">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "to equal", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "within", z.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 [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"to equal">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"within">, z.ZodCustomStringFormat<"duration">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "to be the same date as", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>], (subject: string | number | Date, other: string | number | Date) => {
-    message: string;
-    actual?: undefined;
-    expected?: undefined;
-} | {
-    actual: string;
-    expected: string;
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"to be the same date as">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>]>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]], z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, never>, import("./types.js").AssertionFunctionSync<readonly ["to be a weekday"], (subject: unknown) => {
-    message: string;
-} | undefined, never>, import("./types.js").AssertionFunctionSync<readonly ["to be a weekend"], (subject: unknown) => {
-    message: string;
-} | undefined, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnknown, readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"], z.ZodNonOptional<z.ZodUnknown>], (actual: unknown, context: unknown) => void | import("./types.js").AssertionFailure, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"]>, z.ZodNonOptional<z.ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnknown, readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"], z.ZodNonOptional<z.ZodUnknown>, "with options", z.ZodObject<{
-    hint: z.ZodOptional<z.ZodString>;
-    serializer: z.ZodOptional<z.ZodAny>;
-}, z.core.$strip>], (actual: unknown, context: unknown, options: {
-    hint?: string | undefined;
-    serializer?: any;
-}) => void | import("./types.js").AssertionFailure, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"]>, z.ZodNonOptional<z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"with options">, z.ZodObject<{
-    hint: z.ZodOptional<z.ZodString>;
-    serializer: z.ZodOptional<z.ZodAny>;
-}, z.core.$strip>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, readonly ["to yield", "to emit", "to yield value satisfying"], z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield", "to emit", "to yield value satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield value exhaustively satisfying", z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield value exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield items satisfying", z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield items satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield items exhaustively satisfying", z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield items exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, readonly ["to yield first", "to yield first satisfying"], z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield first", "to yield first satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield first exhaustively satisfying", z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield first exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, readonly ["to yield last", "to yield last satisfying"], z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield last", "to yield last satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield last exhaustively satisfying", z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield last exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield count", z.ZodInt], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expectedCount: number) => {
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield count">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield at least", z.ZodInt], (subject: Iterator<unknown, any, any> | Iterable<unknown>, minCount: number) => {
-    actual: number;
-    expected: string;
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield at least">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield at most", z.ZodInt], (subject: Iterator<unknown, any, any> | Iterable<unknown>, maxCount: number) => {
-    actual: number;
-    expected: string;
-    message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield at most">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.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 [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to be an empty iterable">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield exactly", z.ZodArray<z.ZodUnknown>], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown[]) => {
-    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-    subject: unknown[];
-}, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield exactly">, z.ZodArray<z.ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, readonly ["to yield sequence satisfying", "to yield array satisfying"], z.ZodArray<z.ZodUnknown>], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown[]) => {
-    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-    subject: unknown[];
-}, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield sequence satisfying", "to yield array satisfying"]>, z.ZodArray<z.ZodUnknown>]>], readonly [import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to resolve", "to fulfill"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject", "to be rejected"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject", "to be rejected"]], (subject: PromiseLike<unknown>) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => Promise<{
-    message: string;
-    actual?: undefined;
-    expected?: undefined;
-} | {
-    actual: string;
-    expected: string;
-    message: string;
-} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("./types.js").Constructor) => Promise<{
-    message: string;
-    actual?: undefined;
-    expected?: undefined;
-} | {
-    actual: string;
-    expected: string;
-    message: string;
-} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
-    message: string;
-    schema?: undefined;
-    subject?: undefined;
-} | {
-    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-    subject: {} | null;
-    message?: undefined;
-}>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], z.ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
-    message: string;
-    schema?: undefined;
-    subject?: undefined;
-} | {
-    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-    subject: {} | null;
-    message?: undefined;
-}>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
-    message: string;
-    schema?: undefined;
-    subject?: undefined;
-} | {
-    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-    subject: unknown;
-    message?: undefined;
-}>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
-    message: string;
-    schema?: undefined;
-    subject?: undefined;
-} | {
-    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-    subject: unknown;
-    message?: undefined;
-}>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to yield", "to emit", "to yield value satisfying"], z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield", "to emit", "to yield value satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield value exhaustively satisfying", z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield value exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield items satisfying", z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield items satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield items exhaustively satisfying", z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield items exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to yield first", "to yield first satisfying"], z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield first", "to yield first satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield first exhaustively satisfying", z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield first exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to yield last", "to yield last satisfying"], z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield last", "to yield last satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield last exhaustively satisfying", z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield last exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield count", z.ZodInt], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expectedCount: number) => Promise<{
-    actual: number;
-    expected: number;
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield count">, z.ZodInt]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield at least", z.ZodInt], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, minCount: number) => Promise<{
-    actual: number;
-    expected: string;
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield at least">, z.ZodInt]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield at most", z.ZodInt], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, maxCount: number) => Promise<{
-    actual: number;
-    expected: string;
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield at most">, z.ZodInt]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to be an empty iterable"], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to be an empty iterable">]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield exactly", z.ZodArray<z.ZodUnknown>], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown[]) => Promise<{
-    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-    subject: unknown[];
-}>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield exactly">, z.ZodArray<z.ZodUnknown>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to yield sequence satisfying", "to yield array satisfying"], z.ZodArray<z.ZodUnknown>], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown[]) => Promise<{
-    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
-    subject: unknown[];
-}>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield sequence satisfying", "to yield array satisfying"]>, z.ZodArray<z.ZodUnknown>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to complete", "to finish"]], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to complete", "to finish"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to reject", "to be rejected"]], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to reject with a", "to reject with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expectedType: import("./types.js").Constructor) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expectedShape: unknown) => Promise<{
-    message: string;
-} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, z.ZodUnknown]>]>;
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,UAAU,kCAAkC;AACxD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,uBAAuB;AACrD;;;;;GAKG;AACH,YAAY,EAAE,WAAW,EAAE,kBAAkB;AAC7C,2BAA2B;AAE3B,OAAO,KAAK,MAAM,oBAAoB;AAEtC;;;;GAIG;AACH,YAAY,EACV,eAAe,EACf,eAAe,EACf,eAAe,EACf,kBAAkB,GACnB,8BAA8B;AAE/B;;;GAGG;AACH,OAAO,EAAE,CAAC,EAAE,CAAC;AAEb;;;;;GAKG;AACH,YAAY,EAAE,gBAAgB,EAAE,6BAA6B;AAE7D;;;;;;;;;GASG;AACH,YAAY,KAAK,KAAK,mBAAmB;AAEzC;;GAEG;AACH,YAAY,EACV,gBAAgB,EAChB,4BAA4B,EAC5B,2BAA2B,EAC3B,MAAM,EACN,iBAAiB,EACjB,sBAAsB,EACtB,MAAM,EACN,WAAW,EACX,QAAQ,EACR,aAAa,EACb,MAAM,EACN,OAAO,EACP,KAAK,GACN,mBAAmB;AACpB,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AAC5D,QAAA;AACE;;;;;;;;;GASG;AACH,eAAe;AACf;;;;;;;;;GASG;AACH,oBAAoB;AACpB;;;;;;GAMG;AACH,IAAI;AACJ;;;;;;GAMG;AACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sYAEgB,CAAC"}