bupkis 0.18.0 → 0.18.2

package/dist/schema.d.ts

@@ -1,1196 +0,0 @@
-/**
- * Arguably-useful Zod schemas for common types and validation patterns.
- *
- * This module provides reusable Zod schemas for validating constructors,
- * functions, property keys, promises, and other common JavaScript types used
- * throughout the assertion system. These tend to work around the impedance
- * mismatch between **BUPKIS** and Zod.
- *
- * These are used internally, but consumers may also find them useful.
- *
- * For example, we have {@link FunctionSchema} which accepts any
- * function—regardless of its signature. We need this because Zod v4's
- * `z.function()` no longer returns a `ZodType` (ref:
- * {@link https://zod.dev/v4/changelog | Zod v4 Migration Guide}) and so behaves
- * differently. `FunctionSchema` allows us to work with functions as _values_
- * instead of something to be implemented.
- *
- * Similarly—but not a new development—`z.promise()` does not parse a
- * {@link Promise} object; it parses the _fulfilled value_. This is not what we
- * want for "is a Promise" assertions, but it _can_ be useful for making sense
- * of the fulfilled value. To solve this, we have
- * {@link WrappedPromiseLikeSchema} (which explicitly supports
- * {@link PromiseLike}/"thenable" objects).
- *
- * @module schema
- * @category API
- * @example
- *
- * ```ts
- * import * as schema from 'bupkis/schema';
- * ```
- *
- * @groupDescription Schema
- * Schemas for common types and validation patterns.
- */
-import { z } from 'zod';
-import { type Constructor, type Keypath, type MutableOrReadonly } from "./types.js";
-/**
- * A Zod schema that validates JavaScript constructible functions.
- *
- * This schema validates values that can be used as constructors, including ES6
- * classes, traditional constructor functions, and built-in constructors. It
- * uses the {@link isConstructible} guard function to determine if a value can be
- * invoked with the `new` operator to create object instances.
- *
- * @privateRemarks
- * The schema is registered in the {@link BupkisRegistry} with the name
- * `ConstructibleSchema` for later reference and type checking purposes.
- * @example Direct Usage
- *
- * ```typescript
- * class MyClass {}
- * function MyConstructor() {}
- *
- * ConstructibleSchema.parse(MyClass); // ✓ Valid
- * ConstructibleSchema.parse(MyConstructor); // ✓ Valid
- * ConstructibleSchema.parse(Array); // ✓ Valid
- * ConstructibleSchema.parse(Date); // ✓ Valid
- * ConstructibleSchema.parse(() => {}); // ✗ Throws validation error
- * ConstructibleSchema.parse({}); // ✗ Throws validation error
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { ConstructibleSchema } from 'bupkis/schema';
- *
- * const classAssertion = createAssertion(
- *   [ConstructibleSchema, 'to be a subclass of Error'],
- *   ConstructibleSchema.refine(
- *     (subject) => subject.prototype instanceof Error,
- *   ),
- * );
- *
- * const { expect } = use([classAssertion]);
- * expect(class MyError extends Error {}, 'to be a subclass of Error');
- * ```
- *
- * @group Schema
- */
-export declare const ConstructibleSchema: z.ZodCustom<Constructor, Constructor>;
-/**
- * A Zod schema that validates any JavaScript function.
- *
- * This schema accepts a function having any signature and avoids Zod's parsing
- * overhead.
- *
- * @remarks
- * Zod v~4.0.0 changed how {@link z.function z.function()} worked, which made it
- * unsuitable for validation. This was reverted in Zod v4.1.0.
- * @privateRemarks
- * The schema is registered in the {@link BupkisRegistry} with the name
- * `FunctionSchema` for later reference and type checking purposes.
- * @example Direct Usage
- *
- * ```typescript
- * FunctionSchema.parse(function () {}); // ✓ Valid
- * FunctionSchema.parse(() => {}); // ✓ Valid
- * FunctionSchema.parse(async () => {}); // ✓ Valid
- * FunctionSchema.parse(function* () {}); // ✓ Valid
- * FunctionSchema.parse(Math.max); // ✓ Valid
- * FunctionSchema.parse('not a function'); // ✗ Throws validation error
- * FunctionSchema.parse({}); // ✗ Throws validation error
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { FunctionSchema } from 'bupkis/schema';
- *
- * const fnAssertion = createAssertion(
- *   [FunctionSchema, 'to be a function with arity 2'],
- *   FunctionSchema.refine((subject) => subject.length === 2),
- * );
- * const { expect } = use([fnAssertion]);
- * function add(a: number, b: number) {
- *   return a + b;
- * }
- * expect(add, 'to be a function with arity 2');
- * ```
- *
- * @group Schema
- */
-export declare const FunctionSchema: z.ZodCustom<(...args: MutableOrReadonly<unknown[]>) => unknown, (...args: MutableOrReadonly<unknown[]>) => unknown>;
-/**
- * A Zod schema that validates non-collection objects and functions.
- *
- * Accepts plain objects, functions, arrays, dates, etc. but rejects collection
- * types like `Map`, `Set`, `WeakMap`, and `WeakSet`.
- *
- * @example Direct Usage
- *
- * ```typescript
- * NonCollectionObjectSchema.parse({}); // ✓ Valid
- * NonCollectionObjectSchema.parse({ key: 'value' }); // ✓ Valid
- * NonCollectionObjectSchema.parse(function () {}); // ✓ Valid
- * NonCollectionObjectSchema.parse(() => {}); // ✓ Valid
- * NonCollectionObjectSchema.parse(new Map()); // ✗ Throws validation error
- * NonCollectionObjectSchema.parse(new Set()); // ✗ Throws validation error
- * NonCollectionObjectSchema.parse(null); // ✗ Throws validation error
- * NonCollectionObjectSchema.parse(42); // ✗ Throws validation error
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { NonCollectionObjectSchema } from 'bupkis/schema';
- *
- * const nonCollectionAssertion = createAssertion(
- *   [NonCollectionObjectSchema, 'to be a non-collection object'],
- *   NonCollectionObjectSchema,
- * );
- * const { expect } = use([nonCollectionAssertion]);
- * expect({ key: 'value' }, 'to be a non-collection object');
- * ```
- *
- * @group Schema
- */
-export declare const NonCollectionObjectSchema: z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>;
-/**
- * A Zod schema that validates JavaScript property keys.
- *
- * This schema validates values that can be used as object property keys in
- * JavaScript, which includes strings, numbers, and symbols. These are the three
- * types that JavaScript automatically converts to property keys when used in
- * object access or assignment operations.
- *
- * @privateRemarks
- * The schema is registered in the `BupkisRegistry` with the name
- * `PropertyKeySchema` for later reference and type checking purposes.
- * @example Direct Usage
- *
- * ```typescript
- * PropertyKeySchema.parse('stringKey'); // ✓ Valid
- * PropertyKeySchema.parse(42); // ✓ Valid
- * PropertyKeySchema.parse(Symbol('symbolKey')); // ✓ Valid
- * PropertyKeySchema.parse({}); // ✗ Throws validation error
- * PropertyKeySchema.parse(null); // ✗ Throws validation error
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { PropertyKeySchema } from 'bupkis/schema';
- * const unknownRecordAssertion = createAssertion(
- *   ['to be a record of anything'],
- *   z.record(PropertyKeySchema, z.unknown()),
- * );
- *
- * const { expect } = use([unknownRecordAssertion]);
- * expect(
- *   { 42: pants, shirts: 'foo', [Symbol('baz')]: null },
- *   'to be a record of anything',
- * );
- * ```
- *
- * @group Schema
- */
-export declare const PropertyKeySchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>;
-/**
- * A Zod schema that validates a keypath, which is a string featuring dot
- * notation or bracket notation, used to access nested object properties.
- *
- * Bare numbers must be wrapped in a string.
- *
- * @example Direct Usage
- *
- * ```typescript
- * KeypathSchema.parse('foo.bar'); // ✓ Valid
- * KeypathSchema.parse('arr[0].item'); // ✓ Valid
- * KeypathSchema.parse('obj["key"].prop'); // ✓ Valid
- * KeypathSchema.parse("obj['key'].prop"); // ✓ Valid
- * KeypathSchema.parse('simpleKey'); // ✓ Valid
- * KeypathSchema.parse('42'); // ✓ Valid
- * KeypathSchema.parse('invalid keypath!'); // ✗ Throws validation error
- * KeypathSchema.parse('foo..bar'); // ✗ Throws validation error
- * KeypathSchema.parse('foo[bar]'); // ✗ Throws validation error
- * KeypathSchema.parse(42); // ✗ Throws validation error
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { KeypathSchema } from 'bupkis/schema';
- *
- * const hasKeypathAssertion = createAssertion(
- *   [KeypathSchema, 'to be a keypath'],
- *   KeypathSchema,
- * );
- *
- * const { expect } = use([hasKeypathAssertion]);
- * expect('foo.bar[0]["baz"]', 'to be a keypath');
- * ```
- *
- * @group Schema
- */
-export declare const KeypathSchema: z.ZodType<Keypath>;
-/**
- * A Zod schema that validates "thenable" objects with a `.then()` method.
- *
- * This schema validates objects that implement the PromiseLike interface by
- * having a `.then()` method, which includes Promises and other thenable
- * objects.
- *
- * Unlike Zod's built-in `z.promise()`, this schema does not unwrap the resolved
- * value, meaning the result of parsing remains a Promise or thenable object.
- *
- * @privateRemarks
- * The schema is registered in the `BupkisRegistry` with the name
- * `WrappedPromiseLikeSchema` for later reference and type checking purposes.
- * This is useful when you need to validate that something is thenable without
- * automatically resolving it.
- * @example Direct Usage
- *
- * ```typescript
- * WrappedPromiseLikeSchema.parse(Promise.resolve(42)); // ✓ Valid (returns Promise)
- * WrappedPromiseLikeSchema.parse({ then: () => {} }); // ✓ Valid (thenable)
- * WrappedPromiseLikeSchema.parse(42); // ✗ Throws validation error
- * WrappedPromiseLikeSchema.parse({}); // ✗ Throws validation error
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { WrappedPromiseLikeSchema } from 'bupkis/schema';
- *
- * const thenableAssertion = createAssertion(
- *   [WrappedPromiseLikeSchema, 'to be a thenable'],
- *   WrappedPromiseLikeSchema,
- * );
- *
- * const { expect } = use([thenableAssertion]);
- * // does nothing with 'pants'; await it elsewhere
- * expect({ then: () => Promise.resolve('pants') }, 'to be a thenable');
- * ```
- *
- * @group Schema
- */
-export declare const WrappedPromiseLikeSchema: z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>;
-/**
- * A Zod schema that validates plain objects with null prototypes.
- *
- * > Aliases: {@link NullProtoObjectSchema}, {@link DictionarySchema}
- *
- * This schema validates objects that have been created with
- * `Object.create(null)` or otherwise have their prototype set to `null`. Such
- * objects are "plain" objects without any inherited properties or methods from
- * `Object.prototype`, making them useful as pure data containers or
- * dictionaries.
- *
- * @privateRemarks
- * The schema is registered in the `BupkisRegistry` with the name
- * `ObjectWithNullPrototype` for later reference and type checking purposes.
- *
- * Changing this to be a `ZodRecord` would be nice, but that would end up
- * blasting away the original object's prototype.
- * @example Direct Usage
- *
- * ```typescript
- * const nullProtoObj = Object.create(null);
- * nullProtoObj.key = 'value';
- * NullProtoObjectSchema.parse(nullProtoObj); // ✓ Valid
- *
- * const regularObj = { key: 'value' };
- * NullProtoObjectSchema.parse(regularObj); // ✗ Throws validation error
- *
- * const emptyObj = {};
- * NullProtoObjectSchema.parse(emptyObj); // ✗ Throws validation error
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { DictionarySchema } from 'bupkis/schema';
- *
- * const dictAssertion = createAssertion(
- *   [DictionarySchema, 'to be a dictionary of numbers'],
- *   DictionarySchema.pipe(z.record(z.number())),
- * );
- *
- * const { expect } = use([dictAssertion]);
- *
- * expect(Object.create(null, { pants: { value: 42, enumerable: true } }),
- * ```
- *
- * @group Schema
- */
-export declare const DictionarySchema: z.ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>;
-/**
- * {@inheritDoc DictionarySchema}
- *
- * @group Schema
- */
-export declare const NullProtoObjectSchema: z.ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>;
-/**
- * A Zod schema that validates functions declared with the `async` keyword.
- *
- * This schema validates functions that are explicitly declared as asynchronous
- * using the `async` keyword. It uses runtime introspection to check the
- * function's internal `[[ToString]]` representation to distinguish async
- * functions from regular functions that might return Promises.
- *
- * @remarks
- * **This schema _cannot_ match a function that returns a {@link Promise} but was
- * not declared via `async`.** Determining if a function returns a `Promise` is
- * only possible by execution of said function (which <span
- * class="bupkis">BUPKIS</span> avoids, naturally). This is a limitation of
- * JavaScript itself.
- * @example Direct Usage
- *
- * ```typescript
- * async function asyncFn() {
- *   return 42;
- * }
- * AsyncFunctionSchema.parse(asyncFn); // ✓ Valid
- *
- * const asyncArrow = async () => 42;
- * AsyncFunctionSchema.parse(asyncArrow); // ✓ Valid
- *
- * function syncFn() {
- *   return Promise.resolve(42);
- * }
- * AsyncFunctionSchema.parse(syncFn); // ✗ Throws validation error
- *
- * const regularFn = () => 42;
- * AsyncFunctionSchema.parse(regularFn); // ✗ Throws validation error
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { AsyncFunctionSchema } from 'bupkis/schema';
- *
- * const asyncFnAssertion = createAssertion(
- *   [AsyncFunctionSchema, 'to be an async function'],
- *   AsyncFunctionSchema,
- * );
- *
- * const { expect } = use([asyncFnAssertion]);
- * expect(async () => {}, 'to be an async function');
- * ```
- *
- * @group Schema
- */
-export declare const AsyncFunctionSchema: z.ZodCustom<(...args: MutableOrReadonly<unknown[]>) => unknown, (...args: MutableOrReadonly<unknown[]>) => unknown>;
-/**
- * A Zod schema that validates truthy JavaScript values.
- *
- * This schema accepts any input value but only validates successfully if the
- * value is truthy according to JavaScript's truthiness rules. A value is truthy
- * if it converts to `true` when evaluated in a boolean context - essentially
- * any value that is not one of the eight falsy values.
- *
- * @privateRemarks
- * The schema is registered in the `BupkisRegistry` with the name `Truthy` and
- * indicates that it accepts anything as valid input for evaluation.
- * @example Direct Usage
- *
- * ```typescript
- * TruthySchema.parse(true); // ✓ Valid
- * TruthySchema.parse(1); // ✓ Valid
- * TruthySchema.parse('hello'); // ✓ Valid
- * TruthySchema.parse([]); // ✓ Valid (arrays are truthy)
- * TruthySchema.parse({}); // ✓ Valid (objects are truthy)
- * TruthySchema.parse(false); // ✗ Throws validation error
- * TruthySchema.parse(0); // ✗ Throws validation error
- * TruthySchema.parse(''); // ✗ Throws validation error
- * TruthySchema.parse(null); // ✗ Throws validation error
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { TruthySchema } from 'bupkis/schema';
- *
- * const somethingAssertion = createAssertion(
- *   ['to be something'],
- *   TruthySchema,
- * );
- *
- * const { expect } = use([somethingAssertion]);
- *
- * expect('pants', 'to be something');
- * ```
- *
- * @group Schema
- * @see {@link FalsySchema}
- */
-export declare const TruthySchema: z.ZodNonOptional<z.ZodAny>;
-/**
- * A Zod schema that validates falsy JavaScript values.
- *
- * This schema accepts any input value but only validates successfully if the
- * value is falsy according to JavaScript's truthiness rules. The falsy values
- * in JavaScript are: `false`, `0`, `-0`, `0n`, `""` (empty string), `null`,
- * `undefined`, and `NaN`.
- *
- * @privateRemarks
- * The schema is registered in the `BupkisRegistry` with the name `Falsy` and
- * indicates that it accepts anything as valid input for evaluation.
- * @example Direct Usage
- *
- * ```typescript
- * FalsySchema.parse(false); // ✓ Valid
- * FalsySchema.parse(0); // ✓ Valid
- * FalsySchema.parse(-0); // ✓ Valid
- * FalsySchema.parse(0n); // ✓ Valid (BigInt zero)
- * FalsySchema.parse(''); // ✓ Valid (empty string)
- * FalsySchema.parse(null); // ✓ Valid
- * FalsySchema.parse(undefined); // ✓ Valid
- * FalsySchema.parse(NaN); // ✓ Valid
- * FalsySchema.parse(true); // ✗ Throws validation error
- * FalsySchema.parse(1); // ✗ Throws validation error
- * FalsySchema.parse('hello'); // ✗ Throws validation error
- * FalsySchema.parse({}); // ✗ Throws validation error
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { FalsySchema } from 'bupkis/schema';
- *
- * const falsyAssertion = createAssertion(['to be nothing'], FalsySchema);
- *
- * const { expect } = use([falsyAssertion]);
- *
- * expect('', 'to be nothing');
- * ```
- *
- * @group Schema
- * @see {@link TruthySchema}
- */
-export declare const FalsySchema: z.ZodNullable<z.ZodAny>;
-/**
- * A Zod schema that validates primitive JavaScript values.
- *
- * This schema validates any of the seven primitive data types in JavaScript:
- * string, number, boolean, bigint, symbol, null, and undefined. Primitive
- * values are immutable and are passed by value rather than by reference,
- * distinguishing them from objects and functions which are non-primitive
- * reference types.
- *
- * @privateRemarks
- * The schema is registered in the `BupkisRegistry` with the name `Primitive`
- * and indicates that it accepts primitive values as valid input.
- * @example Direct Usage
- *
- * ```typescript
- * PrimitiveSchema.parse('hello'); // ✓ Valid (string)
- * PrimitiveSchema.parse(42); // ✓ Valid (number)
- * PrimitiveSchema.parse(true); // ✓ Valid (boolean)
- * PrimitiveSchema.parse(BigInt(123)); // ✓ Valid (bigint)
- * PrimitiveSchema.parse(Symbol('test')); // ✓ Valid (symbol)
- * PrimitiveSchema.parse(null); // ✓ Valid (null)
- * PrimitiveSchema.parse(undefined); // ✓ Valid (undefined)
- * PrimitiveSchema.parse({}); // ✗ Throws validation error (object)
- * PrimitiveSchema.parse([]); // ✗ Throws validation error (array)
- * PrimitiveSchema.parse(() => {}); // ✗ Throws validation error (function)
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { PrimitiveSchema } from 'bupkis/schema';
- *
- * const primitiveAssertion = createAssertion(
- *   ['to be a primitive, Date, or RegExp'],
- *   PrimitiveSchema.or(z.instanceof(Date)).or(z.instanceof(RegExp)),
- * );
- *
- * const { expect } = use([primitiveAssertion]);
- *
- * expect('pants', 'to be a primitive, Date, or RegExp');
- * ```
- *
- * @group Schema
- */
-export declare const PrimitiveSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodBigInt, z.ZodSymbol, z.ZodNull, z.ZodUndefined]>;
-/**
- * A Zod schema that validates array-like structures including mutable and
- * readonly variants.
- *
- * This schema validates values that behave like arrays, including standard
- * arrays, tuples with rest elements, and their readonly counterparts. It
- * accepts any array-like structure that can hold elements of any type, making
- * it useful for validating collections where the specific array mutability or
- * tuple structure is not critical.
- *
- * @privateRemarks
- * The schema is registered in the {@link BupkisRegistry} with the name
- * `ArrayLike` for later reference and type checking purposes. This schema is
- * particularly useful when you need to accept various forms of array-like data
- * without being restrictive about mutability or exact tuple structure.
- * @example Direct Usage
- *
- * ```typescript
- * ArrayLikeSchema.parse([1, 2, 3]); // ✓ Valid (mutable array)
- * ArrayLikeSchema.parse(['a', 'b'] as const); // ✓ Valid (readonly array)
- * ArrayLikeSchema.parse([]); // ✓ Valid (empty array)
- * ArrayLikeSchema.parse([42, 'mixed', true]); // ✓ Valid (mixed types)
- * ArrayLikeSchema.parse('not an array'); // ✗ Throws validation error
- * ArrayLikeSchema.parse({}); // ✗ Throws validation error
- * ArrayLikeSchema.parse(null); // ✗ Throws validation error
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { ArrayLikeSchema } from 'bupkis/schema';
- *
- * const argsAssertion = createAssertion(
- *   [ArrayLikeSchema, 'to be a non-array arraylike object'],
- *   ArrayLikeSchema.refine((subject) => !Array.isArray(subject)),
- * );
- *
- * const { expect } = use([argsAssertion]);
- * expect(
- *   (function () {
- *     return arguments;
- *   })(),
- *   'to be a non-array arraylike object',
- * );
- * ```
- *
- * @group Schema
- */
-export declare const ArrayLikeSchema: z.ZodCustom<ArrayLike<unknown>, ArrayLike<unknown>>;
-/**
- * A Zod schema that validates RegExp instances.
- *
- * This schema validates values that are instances of the RegExp class,
- * including regular expressions created with both literal syntax
- * (`/pattern/flags`) and the RegExp constructor (`new RegExp(pattern, flags)`).
- * It ensures the validated value is a proper regular expression object with all
- * associated methods and properties.
- *
- * @privateRemarks
- * The schema is registered in the `BupkisRegistry` with the name `RegExp` for
- * later reference and type checking purposes.
- * @example Direct Usage
- *
- * ```typescript
- * RegExpSchema.parse(/abc/gi); // ✓ Valid (literal syntax)
- * RegExpSchema.parse(new RegExp('abc', 'gi')); // ✓ Valid (constructor)
- * RegExpSchema.parse(/test/); // ✓ Valid (no flags)
- * RegExpSchema.parse(new RegExp('')); // ✓ Valid (empty pattern)
- * RegExpSchema.parse('abc'); // ✗ Throws validation error (string)
- * RegExpSchema.parse(/abc/.source); // ✗ Throws validation error (string pattern)
- * RegExpSchema.parse({}); // ✗ Throws validation error (object)
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { RegExpSchema } from 'bupkis/schema';
- *
- * const globalRegexAssertion = createAssertion(
- *   [RegExpSchema, 'to be a RegExp with the global flag'],
- *   RegExpSchema.refine((subject) => subject.flags.includes('g')),
- * );
- *
- * const { expect } = use([globalRegexAssertion]);
- *
- * expect(/pants/g, 'to be a RegExp with the global flag');
- * ```
- *
- * @group Schema
- */
-export declare const RegExpSchema: z.ZodCustom<RegExp, RegExp>;
-/**
- * A Zod schema that validates non-negative integer values.
- *
- * This schema validates numbers that are both integers (whole numbers without
- * decimal parts) and non-negative (greater than or equal to zero). It combines
- * Zod's integer validation with non-negative validation to ensure the value is
- * a valid count, index, or other non-negative discrete quantity.
- *
- * @privateRemarks
- * The schema is registered in the {@link BupkisRegistry} with the name
- * `nonnegative-integer` for later reference and type checking purposes.
- * @example Direct Usage
- *
- * ```typescript
- * NonNegativeIntegerSchema.parse(0); // ✓ Valid (zero)
- * NonNegativeIntegerSchema.parse(42); // ✓ Valid (positive integer)
- * NonNegativeIntegerSchema.parse(1000); // ✓ Valid (large positive integer)
- * NonNegativeIntegerSchema.parse(-1); // ✗ Throws validation error (negative)
- * NonNegativeIntegerSchema.parse(3.14); // ✗ Throws validation error (not integer)
- * NonNegativeIntegerSchema.parse(-3.14); // ✗ Throws validation error (negative and not integer)
- * NonNegativeIntegerSchema.parse('42'); // ✗ Throws validation error (string)
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { NonNegativeIntegerSchema } from 'bupkis/schema';
- *
- * const arrayIndexAssertion = createAssertion(
- *   [NonNegativeIntegerSchema, 'to be a valid array index'],
- *   NonNegativeIntegerSchema,
- * );
- *
- * const { expect } = use([arrayIndexAssertion]);
- * expect(0, 'to be a valid array index'); // Valid array index
- * expect(5, 'to be a valid array index'); // Valid array index
- * ```
- *
- * @group Schema
- */
-export declare const NonNegativeIntegerSchema: z.ZodInt;
-/**
- * A Zod schema that validates numeric timestamps.
- *
- * This schema validates JavaScript timestamp values (milliseconds since Unix
- * epoch) within the valid range for JavaScript Date objects. It ensures the
- * timestamp is an integer between -8,640,000,000,000,000 and
- * 8,640,000,000,000,000 milliseconds, which corresponds to the range of dates
- * that can be represented by JavaScript's Date object (approximately April 20,
- * 271821 BCE to September 13, 275760 CE).
- *
- * @example
- *
- * ```typescript
- * TimestampFormatSchema.parse(Date.now()); // ✓ Valid current timestamp
- * TimestampFormatSchema.parse(0); // ✓ Valid Unix epoch
- * TimestampFormatSchema.parse(-62135596800000); // ✓ Valid timestamp (year 1 CE)
- * TimestampFormatSchema.parse(1.5); // ✗ Throws - not an integer
- * TimestampFormatSchema.parse(9e15); // ✗ Throws - exceeds maximum timestamp
- * TimestampFormatSchema.parse('1234567890000'); // ✗ Throws - string not number
- * ```
- *
- * @group Schema
- */
-export declare const TimestampFormatSchema: z.ZodInt;
-/**
- * A Zod schema that validates ISO date strings.
- *
- * This schema validates ISO 8601 date and datetime strings in various formats.
- * It accepts both date-only formats (YYYY-MM-DD) and full datetime formats with
- * optional timezone information. The schema supports local datetime strings and
- * those with timezone offsets.
- *
- * @example
- *
- * ```typescript
- * ISODateFormatSchema.parse('2025-01-01'); // ✓ Valid ISO date
- * ISODateFormatSchema.parse('2025-01-01T10:30:00'); // ✓ Valid local datetime
- * ISODateFormatSchema.parse('2025-01-01T10:30:00Z'); // ✓ Valid UTC datetime
- * ISODateFormatSchema.parse('2025-01-01T10:30:00+05:30'); // ✓ Valid with offset
- * ISODateFormatSchema.parse('2025-01-01T10:30:00.123Z'); // ✓ Valid with milliseconds
- * ISODateFormatSchema.parse('01/01/2025'); // ✗ Throws - not ISO format
- * ISODateFormatSchema.parse('2025-13-01'); // ✗ Throws - invalid month
- * ISODateFormatSchema.parse('not-a-date'); // ✗ Throws - invalid format
- * ```
- *
- * @group Schema
- */
-export declare const ISODateFormatSchema: z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>;
-/**
- * A Zod schema that validates date-like values.
- *
- * This schema accepts any value that can represent a date: native JavaScript
- * Date objects, ISO 8601 date strings, or numeric timestamps. It provides a
- * unified validation approach for date inputs across different assertion types.
- * The schema is registered in the BupkisRegistry for use in assertion
- * creation.
- *
- * @privateRemarks
- * This schema is registered with the name 'date-like' in the BupkisRegistry and
- * is commonly used in temporal assertions throughout the library.
- * @example
- *
- * ```typescript
- * DateLikeFormatSchema.parse(new Date()); // ✓ Valid Date object
- * DateLikeFormatSchema.parse('2025-01-01'); // ✓ Valid ISO date string
- * DateLikeFormatSchema.parse('2025-01-01T10:30:00Z'); // ✓ Valid ISO datetime
- * DateLikeFormatSchema.parse(Date.now()); // ✓ Valid timestamp
- * DateLikeFormatSchema.parse(0); // ✓ Valid Unix epoch
- * DateLikeFormatSchema.parse('invalid-date'); // ✗ Throws - invalid format
- * DateLikeFormatSchema.parse({}); // ✗ Throws - not date-like
- * DateLikeFormatSchema.parse(null); // ✗ Throws - null not accepted
- * ```
- *
- * @group Schema
- */
-export declare const DateLikeFormatSchema: z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>;
-/**
- * A Zod schema that validates duration string formats.
- *
- * This schema validates human-readable duration strings using a flexible format
- * that supports various time units with both full names and abbreviations. The
- * format is "{amount} {unit}" where amount is a positive integer and unit can
- * be any supported time unit. Extra whitespace is automatically trimmed.
- *
- * Supported units (case-insensitive):
- *
- * - Milliseconds: `millisecond`, `milliseconds`, `ms`
- * - Seconds: `second`, `seconds`, `s`
- * - Minutes: `minute`, `minutes`, `m`
- * - Hours: `hour`, `hours`, `h`
- * - Days: `day`, `days`, `d`
- * - Weeks: `week`, `weeks`, `w`
- * - Months: `month`, `months` (approximate: 30 days)
- * - Years: `year`, `years`, `y` (approximate: 365 days)
- *
- * @privateRemarks
- * This schema only validates the format; it does not perform any
- * transformations. For converting to milliseconds, use {@link DurationSchema}
- * instead. The schema is registered with the name 'duration' in the
- * BupkisRegistry.
- * @example
- *
- * ```typescript
- * DurationFormatSchema.parse('1 hour'); // ✓ Valid
- * DurationFormatSchema.parse('30 minutes'); // ✓ Valid
- * DurationFormatSchema.parse('2 days'); // ✓ Valid
- * DurationFormatSchema.parse('  5 seconds  '); // ✓ Valid (whitespace trimmed)
- * DurationFormatSchema.parse('1h'); // ✓ Valid abbreviation
- * DurationFormatSchema.parse('10 ms'); // ✓ Valid milliseconds
- * DurationFormatSchema.parse('-5 minutes'); // ✗ Throws - negative not allowed
- * DurationFormatSchema.parse('1.5 hours'); // ✗ Throws - decimal not allowed
- * DurationFormatSchema.parse('5'); // ✗ Throws - missing unit
- * DurationFormatSchema.parse('five minutes'); // ✗ Throws - non-numeric amount
- * ```
- *
- * @group Schema
- */
-export declare const DurationFormatSchema: z.ZodCustomStringFormat<"duration">;
-export declare const DurationSchema: z.ZodPipe<z.ZodCustomStringFormat<"duration">, z.ZodTransform<number, string>>;
-/**
- * Schema that matches any `Set` instance, including those with any element
- * types.
- *
- * This schema is designed for runtime type checking and assertion matching
- * rather than parsing or validation of Set contents. It uses `instanceof`
- * checking to verify that a value is a Set, regardless of what elements it
- * contains.
- *
- * **Usage in Assertions:**
- *
- * - Collection size validation: `expect(mySet, 'to have size', 3)`
- * - Set operations: `expect(setA, 'to be a subset of', setB)`
- * - Emptiness checks: `expect(mySet, 'to be empty')`
- * - Element containment: `expect(mySet, 'to contain', value)`
- *
- * **Why `instanceof` Instead of Zod's `z.set()`:**
- *
- * - `z.set()` requires knowing the element schema at compile time
- * - This schema works with Sets containing any element types
- * - Focuses on the Set structure rather than element validation
- * - Better performance for assertion matching scenarios
- *
- * @example
- *
- * ```ts
- * // Matches any Set regardless of element types
- * SetSchema.parse(new Set([1, 2, 3])); // ✓ passes
- * SetSchema.parse(new Set(['a', 'b'])); // ✓ passes
- * SetSchema.parse(new Set()); // ✓ passes (empty Set)
- * SetSchema.parse([]); // ✗ fails (not a Set)
- * SetSchema.parse(new WeakSet()); // ✗ fails (use AnySetSchema)
- * ```
- *
- * @group Schema
- */
-export declare const SetSchema: z.ZodCustom<Set<unknown>, Set<unknown>>;
-/**
- * Schema that matches either `Set` or `WeakSet` instances.
- *
- * This unified schema handles both strong and weak Set types, making it useful
- * for assertions that should work with either variant. The distinction between
- * Set and WeakSet is important for garbage collection behavior but often
- * irrelevant for structural assertions.
- *
- * **Key Differences Between Set and WeakSet:**
- *
- * - **Set**: Holds strong references, prevents GC, iterable, any value types
- * - **WeakSet**: Holds weak references, allows GC, not iterable, object keys only
- *
- * **Usage Scenarios:**
- *
- * - Generic containment checks that work with both types
- * - Polymorphic collection handling in assertion libraries
- * - APIs that accept either Set variant for flexibility
- *
- * **WeakSet Limitations:**
- *
- * - Only accepts object or symbol values (primitives will cause runtime errors)
- * - Cannot be iterated or have size checked
- * - Some Set-specific assertions may not work with WeakSet
- *
- * @example
- *
- * ```ts
- * // Accepts both Set and WeakSet
- * AnySetSchema.parse(new Set([1, 2, 3])); // ✓ passes
- * AnySetSchema.parse(new WeakSet([obj1, obj2])); // ✓ passes
- * AnySetSchema.parse(new Map()); // ✗ fails (wrong collection type)
- *
- * // Usage in assertions
- * expect(myWeakSet, 'to contain', someObject); // Works with WeakSet
- * expect(mySet, 'to contain', 'string'); // Works with Set
- * ```
- *
- * @group Schema
- */
-export declare const AnySetSchema: z.ZodUnion<[z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>;
-/**
- * Schema that matches any `Map` instance, including those with any key-value
- * types.
- *
- * This schema provides runtime type checking for Map instances without
- * requiring compile-time knowledge of key or value schemas. It uses
- * `instanceof` checking to verify Map structure while being agnostic about the
- * contained data types.
- *
- * **Usage in Assertions:**
- *
- * - Size validation: `expect(myMap, 'to have size', 5)`
- * - Key presence: `expect(myMap, 'to have key', 'someKey')`
- * - Value containment: `expect(myMap, 'to have value', expectedValue)`
- * - Entry validation: `expect(myMap, 'to have entry', [key, value])`
- * - Map equality: `expect(mapA, 'to equal', mapB)`
- *
- * **Advantages Over `z.map()`:**
- *
- * - Works with Maps having heterogeneous key/value types
- * - No need to specify key and value schemas upfront
- * - Optimized for structural validation rather than content parsing
- * - Better error messages for type mismatches in assertions
- *
- * @example
- *
- * ```ts
- * // Matches any Map regardless of key/value types
- * MapSchema.parse(new Map([['key', 'value']])); // ✓ passes
- * MapSchema.parse(
- *   new Map([
- *     [1, 'one'],
- *     [2, 'two'],
- *   ]),
- * ); // ✓ passes
- * MapSchema.parse(new Map()); // ✓ passes (empty Map)
- * MapSchema.parse({}); // ✗ fails (plain object)
- * MapSchema.parse(new WeakMap()); // ✗ fails (use AnyMapSchema)
- * ```
- *
- * @group Schema
- */
-export declare const MapSchema: z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>;
-export declare const WeakMapSchema: z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>;
-/**
- * Schema that matches either `Map` or `WeakMap` instances.
- *
- * This union schema accommodates both strong and weak Map variants, enabling
- * assertions to work polymorphically across both collection types. The choice
- * between Map and WeakMap affects memory management and iteration capabilities
- * but often doesn't impact structural validation logic.
- *
- * **Key Differences Between Map and WeakMap:**
- *
- * - **Map**: Strong references, enumerable, iterable, any key types, has `.size`
- * - **WeakMap**: Weak references, not enumerable, not iterable, object keys only,
- *   no `.size`
- *
- * **Usage Considerations:**
- *
- * - Use for assertions that need to work with either Map type
- * - Particularly useful in library code that accepts either variant
- * - Some Map-specific operations (iteration, size) won't work with WeakMap
- * - WeakMap key restrictions (objects/symbols only) should be considered
- *
- * **Memory Management Implications:**
- *
- * - Map entries prevent garbage collection of keys
- * - WeakMap entries allow garbage collection when keys become unreachable
- * - This affects long-lived caches and memory-sensitive applications
- *
- * @example
- *
- * ```ts
- * // Accepts both Map and WeakMap
- * AnyMapSchema.parse(new Map([['key', 'value']])); // ✓ passes
- * AnyMapSchema.parse(new WeakMap([[obj, 'value']])); // ✓ passes
- * AnyMapSchema.parse(new Set()); // ✗ fails (wrong collection type)
- *
- * // Usage in assertions
- * expect(myWeakMap, 'to have key', someObject); // Works with WeakMap
- * expect(myMap, 'to have key', 'stringKey'); // Works with Map
- * expect(myWeakMap, 'to have size', 3); // ✗ Fails - WeakMap has no size
- * ```
- *
- * @group Schema
- */
-export declare const AnyMapSchema: z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>;
-export declare const StringSchema: z.ZodString;
-export declare const NumberSchema: z.ZodNumber;
-export declare const InfinitySchema: z.ZodLiteral<number>;
-export declare const NegativeInfinitySchema: z.ZodLiteral<number>;
-export declare const BooleanSchema: z.ZodBoolean;
-export declare const PositiveNumberSchema: z.ZodNumber;
-export declare const NegativeNumberSchema: z.ZodNumber;
-export declare const BigintSchema: z.ZodBigInt;
-export declare const SymbolSchema: z.ZodSymbol;
-export declare const UnknownSchema: z.ZodUnknown;
-export declare const UnknownArraySchema: z.ZodArray<z.ZodUnknown>;
-export declare const DateSchema: z.ZodDate;
-export declare const UnknownRecordSchema: z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>;
-export declare const ErrorSchema: z.ZodCustom<Error, Error>;
-export declare const RegexpSchema: z.ZodCustom<RegExp, RegExp>;
-export declare const NullSchema: z.ZodNull;
-export declare const UndefinedSchema: z.ZodUndefined;
-export declare const WeakSetSchema: z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>;
-export declare const WeakRefSchema: z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>;
-export declare const AnyObjectSchema: z.ZodObject<{}, z.core.$loose>;
-/**
- * Schema for snapshot options.
- */
-export declare const SnapshotOptionsSchema: z.ZodObject<{
-    hint: z.ZodOptional<z.ZodString>;
-    serializer: z.ZodOptional<z.ZodAny>;
-}, z.core.$strip>;
-/**
- * Schema matching any synchronous iterable (has `Symbol.iterator` method).
- *
- * This schema validates values that implement the synchronous iteration
- * protocol, meaning they have a `Symbol.iterator` method that returns an
- * iterator. This includes arrays, strings, Sets, Maps, generators, and custom
- * iterable objects.
- *
- * @example Direct Usage
- *
- * ```typescript
- * SyncIterableSchema.parse([1, 2, 3]); // ✓ Valid (array)
- * SyncIterableSchema.parse('hello'); // ✓ Valid (string)
- * SyncIterableSchema.parse(new Set()); // ✓ Valid (Set)
- * SyncIterableSchema.parse(new Map()); // ✓ Valid (Map)
- * SyncIterableSchema.parse(
- *   (function* () {
- *     yield 1;
- *   })(),
- * ); // ✓ Valid (generator)
- * SyncIterableSchema.parse(42); // ✗ Throws validation error
- * SyncIterableSchema.parse({}); // ✗ Throws validation error (plain objects are not iterable)
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { SyncIterableSchema } from 'bupkis/schema';
- *
- * const iterableAssertion = createAssertion(
- *   [SyncIterableSchema, 'to be iterable'],
- *   SyncIterableSchema,
- * );
- *
- * const { expect } = use([iterableAssertion]);
- * expect([1, 2, 3], 'to be iterable');
- * ```
- *
- * @group Schema
- */
-export declare const SyncIterableSchema: z.ZodCustom<Iterable<unknown>, Iterable<unknown>>;
-/**
- * Schema matching any synchronous iterator (has `next()` method).
- *
- * This schema validates values that implement the iterator protocol, meaning
- * they have a `next()` method that returns `{ value, done }` objects. This
- * includes iterator objects returned from calling `Symbol.iterator` on
- * iterables, generator objects, and custom iterator implementations.
- *
- * @remarks
- * Note that most iterators are also iterable (they have `Symbol.iterator`
- * returning `this`), but this schema specifically checks for the `next()`
- * method which is the core iterator requirement.
- * @example Direct Usage
- *
- * ```typescript
- * const arr = [1, 2, 3];
- * SyncIteratorSchema.parse(arr[Symbol.iterator]()); // ✓ Valid
- * SyncIteratorSchema.parse(
- *   (function* () {
- *     yield 1;
- *   })(),
- * ); // ✓ Valid (generators are iterators)
- * SyncIteratorSchema.parse({
- *   next: () => ({ done: true, value: undefined }),
- * }); // ✓ Valid
- * SyncIteratorSchema.parse([1, 2, 3]); // ✗ Throws (array is iterable, not iterator)
- * SyncIteratorSchema.parse({}); // ✗ Throws validation error
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { SyncIteratorSchema } from 'bupkis/schema';
- *
- * const iteratorAssertion = createAssertion(
- *   [SyncIteratorSchema, 'to be an iterator'],
- *   SyncIteratorSchema,
- * );
- *
- * const { expect } = use([iteratorAssertion]);
- * expect([1, 2, 3][Symbol.iterator](), 'to be an iterator');
- * ```
- *
- * @group Schema
- */
-export declare const SyncIteratorSchema: z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>;
-/**
- * Schema matching either a sync iterable or sync iterator.
- *
- * This union schema accepts values that implement either the iterable protocol
- * (has `Symbol.iterator`) or the iterator protocol (has `next()` method). This
- * is useful for assertions that can work with either form, allowing users to
- * pass arrays, generators, or raw iterators interchangeably.
- *
- * @example Direct Usage
- *
- * ```typescript
- * SyncIterableOrIteratorSchema.parse([1, 2, 3]); // ✓ Valid (iterable)
- * SyncIterableOrIteratorSchema.parse([1, 2, 3][Symbol.iterator]()); // ✓ Valid (iterator)
- * SyncIterableOrIteratorSchema.parse(
- *   (function* () {
- *     yield 1;
- *   })(),
- * ); // ✓ Valid (both)
- * SyncIterableOrIteratorSchema.parse(42); // ✗ Throws validation error
- * ```
- *
- * @group Schema
- */
-export declare const SyncIterableOrIteratorSchema: z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>;
-/**
- * Schema matching any asynchronous iterable (has `Symbol.asyncIterator`
- * method).
- *
- * This schema validates values that implement the asynchronous iteration
- * protocol, meaning they have a `Symbol.asyncIterator` method that returns an
- * async iterator. This includes async generators, Node.js Readable streams
- * (v10+), and Web ReadableStreams (in modern browsers and Node.js v22+).
- *
- * @example Direct Usage
- *
- * ```typescript
- * AsyncIterableSchema.parse(
- *   (async function* () {
- *     yield 1;
- *   })(),
- * ); // ✓ Valid (async generator)
- * AsyncIterableSchema.parse(Readable.from([1, 2, 3])); // ✓ Valid (Node stream)
- * AsyncIterableSchema.parse(new ReadableStream()); // ✓ Valid (Web stream, Node 22+)
- * AsyncIterableSchema.parse([1, 2, 3]); // ✗ Throws (sync iterable, not async)
- * AsyncIterableSchema.parse(Promise.resolve(1)); // ✗ Throws (Promise is not iterable)
- * ```
- *
- * @example Assertion Creation
- *
- * ```ts
- * import { createAssertion, use } from 'bupkis';
- * import { AsyncIterableSchema } from 'bupkis/schema';
- *
- * const asyncIterableAssertion = createAssertion(
- *   [AsyncIterableSchema, 'to be an async iterable'],
- *   AsyncIterableSchema,
- * );
- *
- * const { expect } = use([asyncIterableAssertion]);
- * expect(
- *   (async function* () {
- *     yield 1;
- *   })(),
- *   'to be an async iterable',
- * );
- * ```
- *
- * @group Schema
- */
-export declare const AsyncIterableSchema: z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>;
-/**
- * Schema matching any asynchronous iterator (has async `next()` method).
- *
- * This schema validates values that implement the async iterator protocol,
- * meaning they have a `next()` method that returns a Promise of `{ value, done
- * }`. This includes async iterator objects and custom async iterator
- * implementations.
- *
- * @remarks
- * This schema checks for the presence of a `next()` method but cannot verify at
- * parse time that it returns a Promise. The async behavior is validated at
- * iteration time.
- * @example Direct Usage
- *
- * ```typescript
- * const asyncGen = (async function* () {
- *   yield 1;
- * })();
- * AsyncIteratorSchema.parse(asyncGen); // ✓ Valid (async generator is also iterator)
- * AsyncIteratorSchema.parse({
- *   next: async () => ({ done: true, value: undefined }),
- * }); // ✓ Valid
- * AsyncIteratorSchema.parse([1, 2, 3][Symbol.iterator]()); // ✓ Valid (has next())
- * AsyncIteratorSchema.parse({}); // ✗ Throws validation error
- * ```
- *
- * @group Schema
- */
-export declare const AsyncIteratorSchema: z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>;
-/**
- * Schema matching either an async iterable or async iterator. Also accepts sync
- * iterables (can be consumed async).
- *
- * This permissive union schema accepts values that can be iterated
- * asynchronously, including:
- *
- * - Async iterables (has `Symbol.asyncIterator`)
- * - Async iterators (has async `next()`)
- * - Sync iterables (has `Symbol.iterator`) - these can be consumed via async
- *   iteration
- *
- * This flexibility allows async assertions to work uniformly with various
- * iterable types.
- *
- * @example Direct Usage
- *
- * ```typescript
- * AsyncIterableOrIteratorSchema.parse(
- *   (async function* () {
- *     yield 1;
- *   })(),
- * ); // ✓ Valid
- * AsyncIterableOrIteratorSchema.parse([1, 2, 3]); // ✓ Valid (sync iterable works)
- * AsyncIterableOrIteratorSchema.parse(Readable.from([1, 2, 3])); // ✓ Valid
- * AsyncIterableOrIteratorSchema.parse(42); // ✗ Throws validation error
- * ```
- *
- * @group Schema
- */
-export declare const AsyncIterableOrIteratorSchema: 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>>]>;
-//# sourceMappingURL=schema.d.ts.map