valrs 0.1.0

package/dist/v.d.ts

@@ -0,0 +1,1382 @@
+/**
+ * Zod-compatible fluent API for valrs.
+ *
+ * This module provides a `v` namespace with schema builders that mirror
+ * Zod's API while maintaining Standard Schema compliance.
+ *
+ * @example
+ * ```typescript
+ * import { v } from 'valrs';
+ *
+ * // Create schemas
+ * const userSchema = v.object({
+ *   name: v.string(),
+ *   age: v.number(),
+ * });
+ *
+ * // Parse data
+ * const user = userSchema.parse({ name: 'Alice', age: 30 });
+ *
+ * // Infer types
+ * type User = v.infer<typeof userSchema>;
+ * ```
+ */
+import type { StandardSchemaV1 } from './types';
+import { ValSchema, ValArray, ValUnion, ValIntersection, ValPreprocessed } from './schema';
+import { stream, streamLines, createMockStream, createChunkedStream } from './streaming';
+export type { StreamOptions, StreamResult, StreamError, StreamResultWithErrors, StreamInput, } from './streaming';
+export type { SafeParseResult, SafeParseSuccess, SafeParseError, } from './schema';
+export { ValSchema } from './schema';
+export { isSafeParseSuccess, isSafeParseError } from './schema';
+import { ValError as ValErrorClass, setErrorMap as setErrorMapFn, getErrorMap as getErrorMapFn, resetErrorMap as resetErrorMapFn, getTypeName, createInvalidTypeIssue, createTooSmallIssue, createTooBigIssue, createInvalidStringIssue, createInvalidEnumValueIssue, createInvalidUnionIssue, createUnrecognizedKeysIssue, createCustomIssue, createInvalidLiteralIssue, createNotMultipleOfIssue, createNotFiniteIssue, createInvalidDateIssue } from './error';
+export declare const ValError: typeof ValErrorClass;
+export declare const setErrorMap: typeof setErrorMapFn;
+export declare const getErrorMap: typeof getErrorMapFn;
+export declare const resetErrorMap: typeof resetErrorMapFn;
+export { getTypeName, createInvalidTypeIssue, createTooSmallIssue, createTooBigIssue, createInvalidStringIssue, createInvalidEnumValueIssue, createInvalidUnionIssue, createUnrecognizedKeysIssue, createCustomIssue, createInvalidLiteralIssue, createNotMultipleOfIssue, createNotFiniteIssue, createInvalidDateIssue, };
+export type { ValIssueCode, ValIssueBase, ValIssue, InvalidTypeIssue, TooSmallIssue, TooBigIssue, InvalidStringIssue, InvalidEnumValueIssue, InvalidUnionIssue, CustomIssue, SizeType, ErrorMapFn, ErrorMapContext, FormattedError, FlattenedError, } from './error';
+/**
+ * Infers the output type from a schema.
+ *
+ * This is the primary type inference utility, matching Zod's `z.infer`.
+ *
+ * @example
+ * ```typescript
+ * const schema = v.string();
+ * type MyString = v.infer<typeof schema>; // string
+ * ```
+ */
+export type Infer<T extends ValSchema<unknown, unknown>> = T extends ValSchema<unknown, infer O> ? O : never;
+export type infer<T extends ValSchema<unknown, unknown>> = Infer<T>;
+/**
+ * Infers the input type from a schema.
+ *
+ * Use this when the input type differs from the output type
+ * (e.g., with coercion or transforms).
+ *
+ * @example
+ * ```typescript
+ * const schema = v.coerce.number();
+ * type Input = v.input<typeof schema>;  // unknown
+ * type Output = v.output<typeof schema>; // number
+ * ```
+ */
+export type input<T extends ValSchema<unknown, unknown>> = T extends ValSchema<infer I, unknown> ? I : never;
+/**
+ * Infers the output type from a schema.
+ *
+ * Alias for `v.infer` for symmetry with `v.input`.
+ */
+export type output<T extends ValSchema<unknown, unknown>> = Infer<T>;
+type StringValidator = (value: string) => {
+    issues: Array<{
+        message: string;
+    }>;
+} | null;
+type StringTransform = (value: string) => string;
+/**
+ * Schema for string values with validation and transformation methods.
+ *
+ * Supports chainable methods like `.min()`, `.max()`, `.email()`, `.url()`, etc.
+ * Each method returns a new schema instance (immutable).
+ *
+ * @example
+ * ```typescript
+ * const emailSchema = v.string().email();
+ * const usernameSchema = v.string().min(3).max(20);
+ * const normalizedSchema = v.string().trim().toLowerCase();
+ * ```
+ */
+export declare class ValString extends ValSchema<string, string> {
+    private readonly validators;
+    private readonly transforms;
+    constructor(validators?: ReadonlyArray<StringValidator>, transforms?: ReadonlyArray<StringTransform>);
+    /**
+     * Creates a copy of this schema with additional validators/transforms.
+     */
+    private clone;
+    /**
+     * Requires string to be at least `length` characters.
+     */
+    min(length: number, message?: string): ValString;
+    /**
+     * Requires string to be at most `length` characters.
+     */
+    max(length: number, message?: string): ValString;
+    /**
+     * Requires string to be exactly `len` characters.
+     */
+    length(len: number, message?: string): ValString;
+    /**
+     * Validates that the string is a valid email address.
+     */
+    email(message?: string): ValString;
+    /**
+     * Validates that the string is a valid URL.
+     */
+    url(message?: string): ValString;
+    /**
+     * Validates that the string is a valid UUID.
+     */
+    uuid(message?: string): ValString;
+    /**
+     * Validates that the string is a valid CUID.
+     */
+    cuid(message?: string): ValString;
+    /**
+     * Validates that the string is a valid CUID2.
+     */
+    cuid2(message?: string): ValString;
+    /**
+     * Validates that the string is a valid ULID.
+     */
+    ulid(message?: string): ValString;
+    /**
+     * Validates that the string matches the provided regex pattern.
+     */
+    regex(pattern: RegExp, message?: string): ValString;
+    /**
+     * Validates that the string is a valid ISO 8601 datetime.
+     */
+    datetime(message?: string): ValString;
+    /**
+     * Validates that the string is a valid IP address (v4 or v6).
+     */
+    ip(message?: string): ValString;
+    /**
+     * Validates that the string includes the specified substring.
+     */
+    includes(needle: string, message?: string): ValString;
+    /**
+     * Validates that the string starts with the specified prefix.
+     */
+    startsWith(prefix: string, message?: string): ValString;
+    /**
+     * Validates that the string ends with the specified suffix.
+     */
+    endsWith(suffix: string, message?: string): ValString;
+    /**
+     * Trims whitespace from both ends of the string.
+     */
+    trim(): ValString;
+    /**
+     * Converts the string to lowercase.
+     */
+    toLowerCase(): ValString;
+    /**
+     * Converts the string to uppercase.
+     */
+    toUpperCase(): ValString;
+}
+type NumberValidator = (value: number) => {
+    issues: Array<{
+        message: string;
+    }>;
+} | null;
+/**
+ * Schema for number values with validation methods.
+ *
+ * Supports chainable methods like `.gt()`, `.gte()`, `.int()`, `.positive()`, etc.
+ * Each method returns a new schema instance (immutable).
+ *
+ * @example
+ * ```typescript
+ * const ageSchema = v.number().int().positive();
+ * const priceSchema = v.number().gte(0).lte(1000);
+ * const percentSchema = v.number().gte(0).lte(100);
+ * ```
+ */
+export declare class ValNumber extends ValSchema<number, number> {
+    private readonly validators;
+    constructor(validators?: ReadonlyArray<NumberValidator>);
+    /**
+     * Creates a copy of this schema with additional validators.
+     */
+    private clone;
+    /**
+     * Requires number to be greater than `value`.
+     */
+    gt(value: number, message?: string): ValNumber;
+    /**
+     * Requires number to be greater than or equal to `value`.
+     */
+    gte(value: number, message?: string): ValNumber;
+    /**
+     * Alias for `gte()`.
+     */
+    min(value: number, message?: string): ValNumber;
+    /**
+     * Requires number to be less than `value`.
+     */
+    lt(value: number, message?: string): ValNumber;
+    /**
+     * Requires number to be less than or equal to `value`.
+     */
+    lte(value: number, message?: string): ValNumber;
+    /**
+     * Alias for `lte()`.
+     */
+    max(value: number, message?: string): ValNumber;
+    /**
+     * Requires number to be an integer.
+     */
+    int(message?: string): ValNumber;
+    /**
+     * Requires number to be positive (> 0).
+     */
+    positive(message?: string): ValNumber;
+    /**
+     * Requires number to be non-negative (>= 0).
+     */
+    nonnegative(message?: string): ValNumber;
+    /**
+     * Requires number to be negative (< 0).
+     */
+    negative(message?: string): ValNumber;
+    /**
+     * Requires number to be non-positive (<= 0).
+     */
+    nonpositive(message?: string): ValNumber;
+    /**
+     * Requires number to be a multiple of `value`.
+     *
+     * Uses tolerance-based comparison to handle floating point precision issues.
+     */
+    multipleOf(value: number, message?: string): ValNumber;
+    /**
+     * Alias for `multipleOf()`.
+     */
+    step(value: number, message?: string): ValNumber;
+    /**
+     * Requires number to be finite (not Infinity or -Infinity).
+     */
+    finite(message?: string): ValNumber;
+    /**
+     * Requires number to be a safe integer (within Number.MIN_SAFE_INTEGER to Number.MAX_SAFE_INTEGER).
+     */
+    safe(message?: string): ValNumber;
+}
+/**
+ * Schema for bigint values.
+ *
+ * Validates that the input is a JavaScript BigInt.
+ */
+export declare class ValBigInt extends ValSchema<bigint, bigint> {
+    constructor();
+}
+/**
+ * Schema for boolean values.
+ */
+export declare class ValBoolean extends ValSchema<boolean, boolean> {
+    constructor();
+}
+/**
+ * Schema for Date values.
+ *
+ * Validates that the input is a valid Date object (not Invalid Date).
+ */
+export declare class ValDate extends ValSchema<Date, Date> {
+    constructor();
+}
+/**
+ * Schema for undefined values.
+ */
+export declare class ValUndefined extends ValSchema<undefined, undefined> {
+    constructor();
+    isOptional(): boolean;
+}
+/**
+ * Schema for null values.
+ */
+export declare class ValNull extends ValSchema<null, null> {
+    constructor();
+    isNullable(): boolean;
+}
+/**
+ * Schema for void (undefined).
+ *
+ * Alias for undefined schema, matching Zod's behavior.
+ */
+export declare class ValVoid extends ValSchema<void, void> {
+    constructor();
+}
+/**
+ * Schema that accepts any value.
+ *
+ * Use sparingly - prefer more specific schemas when possible.
+ */
+export declare class ValAny extends ValSchema<any, any> {
+    constructor();
+}
+/**
+ * Schema that accepts any value as unknown.
+ *
+ * Unlike `any`, `unknown` requires type narrowing before use.
+ */
+export declare class ValUnknown extends ValSchema<unknown, unknown> {
+    constructor();
+}
+/**
+ * Schema that never validates successfully.
+ *
+ * Useful for exhaustive type checking and unreachable code paths.
+ */
+export declare class ValNever extends ValSchema<never, never> {
+    constructor();
+}
+/**
+ * Schema for 32-bit signed integers.
+ */
+export declare class ValInt32 extends ValSchema<number, number> {
+    constructor();
+}
+/**
+ * Schema for 64-bit signed integers.
+ */
+export declare class ValInt64 extends ValSchema<number, number> {
+    constructor();
+}
+/**
+ * Schema for 32-bit unsigned integers.
+ */
+export declare class ValUint32 extends ValSchema<number, number> {
+    constructor();
+}
+/**
+ * Schema for 64-bit unsigned integers.
+ */
+export declare class ValUint64 extends ValSchema<number, number> {
+    constructor();
+}
+/**
+ * Schema for 32-bit floating point numbers.
+ */
+export declare class ValFloat32 extends ValSchema<number, number> {
+    constructor();
+}
+/**
+ * Schema for 64-bit floating point numbers.
+ */
+export declare class ValFloat64 extends ValSchema<number, number> {
+    constructor();
+}
+/**
+ * A shape is a record of string keys to ValSchema instances.
+ */
+type Shape = Record<string, ValSchema<unknown, unknown>>;
+/**
+ * Infers the input type from a shape definition.
+ */
+type InferShapeInput<T extends Shape> = {
+    [K in keyof T]: T[K] extends ValSchema<infer I, unknown> ? I : never;
+};
+/**
+ * Infers the output type from a shape definition.
+ */
+type InferShapeOutput<T extends Shape> = {
+    [K in keyof T]: T[K] extends ValSchema<unknown, infer O> ? O : never;
+};
+/**
+ * Gets the keys that are optional in a shape (schemas that accept undefined).
+ */
+type OptionalKeys<T extends Shape> = {
+    [K in keyof T]: undefined extends InferShapeOutput<T>[K] ? K : never;
+}[keyof T];
+/**
+ * Gets the keys that are required in a shape.
+ */
+type RequiredKeys<T extends Shape> = Exclude<keyof T, OptionalKeys<T>>;
+/**
+ * Builds the proper object type with optional keys marked with ?.
+ */
+type BuildObjectType<T extends Shape> = {
+    [K in RequiredKeys<T>]: InferShapeOutput<T>[K];
+} & {
+    [K in OptionalKeys<T>]?: InferShapeOutput<T>[K];
+};
+/**
+ * Flatten intersection types for better readability.
+ */
+type Flatten<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Unknown key handling mode for object schemas.
+ */
+type UnknownKeyMode = 'strip' | 'strict' | 'passthrough';
+/**
+ * Schema for object values with a defined shape.
+ *
+ * Supports validation of each property, unknown key handling, and various
+ * transformation methods like pick, omit, partial, extend, etc.
+ *
+ * @template T - The shape definition (record of property schemas)
+ *
+ * @example
+ * ```typescript
+ * const User = v.object({
+ *   name: v.string(),
+ *   age: v.number().int().positive(),
+ *   email: v.string().email().optional(),
+ * });
+ *
+ * type User = v.infer<typeof User>;
+ * // { name: string; age: number; email?: string }
+ *
+ * User.parse({ name: 'Alice', age: 30 });
+ * ```
+ */
+export declare class ValObject<T extends Shape> extends ValSchema<Flatten<InferShapeInput<T>>, Flatten<BuildObjectType<T>>> {
+    /**
+     * The shape definition containing all property schemas.
+     */
+    readonly shape: T;
+    private readonly unknownKeyMode;
+    private readonly catchallSchema;
+    constructor(shape: T, unknownKeyMode?: UnknownKeyMode, catchallSchema?: ValSchema<unknown, unknown> | null);
+    /**
+     * Extends the object schema with additional properties.
+     *
+     * @param augmentation - Additional property schemas to add
+     * @returns A new object schema with the combined shape
+     *
+     * @example
+     * ```typescript
+     * const User = v.object({ name: v.string() });
+     * const Admin = User.extend({ role: v.string() });
+     * // { name: string; role: string }
+     * ```
+     */
+    extend<U extends Shape>(augmentation: U): ValObject<Flatten<T & U>>;
+    /**
+     * Merges this object schema with another object schema.
+     *
+     * Properties from the other schema override properties in this schema.
+     *
+     * @param other - Another object schema to merge with
+     * @returns A new object schema with the merged shape
+     *
+     * @example
+     * ```typescript
+     * const A = v.object({ a: v.string(), shared: v.number() });
+     * const B = v.object({ b: v.boolean(), shared: v.string() });
+     * const Merged = A.merge(B);
+     * // { a: string; b: boolean; shared: string }
+     * ```
+     */
+    merge<U extends Shape>(other: ValObject<U>): ValObject<Flatten<T & U>>;
+    /**
+     * Creates a new schema with only the specified keys.
+     *
+     * @param mask - An object with keys to pick (values should be true)
+     * @returns A new object schema with only the picked keys
+     *
+     * @example
+     * ```typescript
+     * const User = v.object({ name: v.string(), age: v.number(), email: v.string() });
+     * const NameOnly = User.pick({ name: true });
+     * // { name: string }
+     * ```
+     */
+    pick<K extends keyof T>(mask: {
+        [key in K]: true;
+    }): ValObject<Pick<T, K>>;
+    /**
+     * Creates a new schema without the specified keys.
+     *
+     * @param mask - An object with keys to omit (values should be true)
+     * @returns A new object schema without the omitted keys
+     *
+     * @example
+     * ```typescript
+     * const User = v.object({ name: v.string(), age: v.number(), email: v.string() });
+     * const WithoutEmail = User.omit({ email: true });
+     * // { name: string; age: number }
+     * ```
+     */
+    omit<K extends keyof T>(mask: {
+        [key in K]: true;
+    }): ValObject<Omit<T, K>>;
+    /**
+     * Makes all properties optional.
+     *
+     * @returns A new object schema where all properties are optional
+     *
+     * @example
+     * ```typescript
+     * const User = v.object({ name: v.string(), age: v.number() });
+     * const PartialUser = User.partial();
+     * // { name?: string; age?: number }
+     * ```
+     */
+    partial(): ValObject<{
+        [K in keyof T]: ReturnType<T[K]['optional']>;
+    }>;
+    /**
+     * Makes all properties deeply optional (recursive).
+     *
+     * For nested objects, this recursively applies partial().
+     *
+     * @returns A new object schema where all properties are deeply optional
+     *
+     * @example
+     * ```typescript
+     * const User = v.object({
+     *   name: v.string(),
+     *   address: v.object({ city: v.string(), zip: v.string() }),
+     * });
+     * const DeepPartialUser = User.deepPartial();
+     * // { name?: string; address?: { city?: string; zip?: string } }
+     * ```
+     */
+    deepPartial(): ValObject<{
+        [K in keyof T]: ReturnType<T[K]['optional']>;
+    }>;
+    /**
+     * Makes all properties required (removes optional).
+     *
+     * @returns A new object schema where all properties are required
+     *
+     * @example
+     * ```typescript
+     * const PartialUser = v.object({ name: v.string().optional(), age: v.number().optional() });
+     * const User = PartialUser.required();
+     * // { name: string; age: number }
+     * ```
+     */
+    required(): ValObject<{
+        [K in keyof T]: ValSchema<unknown, Exclude<InferShapeOutput<T>[K], undefined>>;
+    }>;
+    /**
+     * Allows unknown keys to pass through without validation.
+     *
+     * @returns A new object schema that preserves unknown keys
+     *
+     * @example
+     * ```typescript
+     * const User = v.object({ name: v.string() }).passthrough();
+     * User.parse({ name: 'Alice', extra: 'value' });
+     * // { name: 'Alice', extra: 'value' }
+     * ```
+     */
+    passthrough(): ValObject<T>;
+    /**
+     * Rejects any unknown keys (throws validation error).
+     *
+     * @returns A new object schema that rejects unknown keys
+     *
+     * @example
+     * ```typescript
+     * const User = v.object({ name: v.string() }).strict();
+     * User.parse({ name: 'Alice', extra: 'value' }); // throws
+     * ```
+     */
+    strict(): ValObject<T>;
+    /**
+     * Silently removes unknown keys (default behavior).
+     *
+     * @returns A new object schema that strips unknown keys
+     *
+     * @example
+     * ```typescript
+     * const User = v.object({ name: v.string() }).strip();
+     * User.parse({ name: 'Alice', extra: 'value' });
+     * // { name: 'Alice' }
+     * ```
+     */
+    strip(): ValObject<T>;
+    /**
+     * Validates unknown keys with the provided schema.
+     *
+     * @param schema - Schema to validate unknown keys with
+     * @returns A new object schema that validates unknown keys
+     *
+     * @example
+     * ```typescript
+     * const Metadata = v.object({ id: v.string() }).catchall(v.number());
+     * Metadata.parse({ id: 'abc', count: 42, score: 100 });
+     * // { id: 'abc', count: 42, score: 100 }
+     * ```
+     */
+    catchall<U>(schema: ValSchema<unknown, U>): ValObject<T>;
+    /**
+     * Returns a schema that validates to a union of the object's literal keys.
+     *
+     * @returns A schema for the object's keys as literals
+     *
+     * @example
+     * ```typescript
+     * const User = v.object({ name: v.string(), age: v.number() });
+     * const UserKey = User.keyof();
+     * UserKey.parse('name'); // 'name'
+     * UserKey.parse('age');  // 'age'
+     * UserKey.parse('email'); // throws
+     * ```
+     */
+    keyof(): ValLiteral<keyof T & string>;
+}
+/**
+ * Schema for literal union values.
+ *
+ * Used by object.keyof() to create a schema that validates to one of the
+ * object's keys.
+ *
+ * @template T - The union of literal values
+ */
+export declare class ValLiteral<T extends string> extends ValSchema<T, T> {
+    readonly values: ReadonlyArray<T>;
+    constructor(values: ReadonlyArray<T>);
+}
+export { ValArray, ValUnion, ValIntersection } from './schema';
+/**
+ * Helper type to infer input type from a schema.
+ */
+type InferSchemaInput<T extends ValSchema<unknown, unknown>> = T extends ValSchema<infer I, unknown> ? I : never;
+/**
+ * Helper type to infer output type from a schema.
+ */
+type InferSchemaOutput<T extends ValSchema<unknown, unknown>> = T extends ValSchema<unknown, infer O> ? O : never;
+/**
+ * Infers tuple input type from an array of schemas.
+ */
+type InferTupleInput<T extends ReadonlyArray<ValSchema<unknown, unknown>>> = {
+    [K in keyof T]: T[K] extends ValSchema<infer I, unknown> ? I : never;
+};
+/**
+ * Infers tuple output type from an array of schemas.
+ */
+type InferTupleOutput<T extends ReadonlyArray<ValSchema<unknown, unknown>>> = {
+    [K in keyof T]: T[K] extends ValSchema<unknown, infer O> ? O : never;
+};
+/**
+ * Schema for tuple values with fixed element types.
+ *
+ * @template T - The array of element schemas
+ *
+ * @example
+ * ```typescript
+ * const schema = v.tuple([v.string(), v.number()]);
+ * schema.parse(['hello', 42]); // ['hello', 42]
+ *
+ * type Tuple = v.infer<typeof schema>; // [string, number]
+ * ```
+ */
+export declare class ValTuple<T extends ReadonlyArray<ValSchema<unknown, unknown>>, R extends ValSchema<unknown, unknown> | null = null> extends ValSchema<R extends ValSchema<infer RI, unknown> ? [...InferTupleInput<T>, ...RI[]] : InferTupleInput<T>, R extends ValSchema<unknown, infer RO> ? [...InferTupleOutput<T>, ...RO[]] : InferTupleOutput<T>> {
+    readonly items: T;
+    constructor(items: T, restSchema?: R);
+    /**
+     * Adds a rest element type to the tuple.
+     *
+     * @example
+     * ```typescript
+     * const schema = v.tuple([v.string()]).rest(v.number());
+     * schema.parse(['hello', 1, 2, 3]); // ['hello', 1, 2, 3]
+     *
+     * type T = v.infer<typeof schema>; // [string, ...number[]]
+     * ```
+     */
+    rest<RNew extends ValSchema<unknown, unknown>>(restSchema: RNew): ValTuple<T, RNew>;
+}
+/**
+ * Infers union input type from an array of schemas.
+ */
+type InferUnionInput<T extends ReadonlyArray<ValSchema<unknown, unknown>>> = T[number] extends ValSchema<infer I, unknown> ? I : never;
+/**
+ * Infers union output type from an array of schemas.
+ */
+type InferUnionOutput<T extends ReadonlyArray<ValSchema<unknown, unknown>>> = T[number] extends ValSchema<unknown, infer O> ? O : never;
+/**
+ * Schema for discriminated union types (tagged unions).
+ *
+ * Provides better error messages by identifying the discriminator first.
+ *
+ * @example
+ * ```typescript
+ * const schema = v.discriminatedUnion('type', [
+ *   v.object({ type: v.literal('a'), value: v.string() }),
+ *   v.object({ type: v.literal('b'), count: v.number() }),
+ * ]);
+ *
+ * schema.parse({ type: 'a', value: 'hello' }); // OK
+ * schema.parse({ type: 'b', count: 42 });      // OK
+ * ```
+ */
+export declare class ValDiscriminatedUnion<D extends string, T extends ReadonlyArray<ValObject<Shape>>> extends ValSchema<InferUnionInput<T>, InferUnionOutput<T>> {
+    readonly discriminator: D;
+    readonly options: T;
+    constructor(discriminator: D, options: T);
+}
+/**
+ * Schema for record/dictionary values with string keys.
+ *
+ * @template K - Key schema (must be string)
+ * @template V - Value schema
+ *
+ * @example
+ * ```typescript
+ * const schema = v.record(v.string());
+ * schema.parse({ a: 'hello', b: 'world' }); // OK
+ *
+ * const typedRecord = v.record(v.string(), v.number());
+ * typedRecord.parse({ count: 42, score: 100 }); // OK
+ * ```
+ */
+export declare class ValRecord<K extends ValSchema<string, string>, V extends ValSchema<unknown, unknown>> extends ValSchema<Record<InferSchemaOutput<K>, InferSchemaInput<V>>, Record<InferSchemaOutput<K>, InferSchemaOutput<V>>> {
+    readonly keySchema: K;
+    readonly valueSchema: V;
+    constructor(keySchema: K, valueSchema: V);
+}
+/**
+ * Schema for JavaScript Map objects.
+ *
+ * @template K - Key schema
+ * @template V - Value schema
+ *
+ * @example
+ * ```typescript
+ * const schema = v.map(v.string(), v.number());
+ * const map = new Map([['a', 1], ['b', 2]]);
+ * schema.parse(map); // Map { 'a' => 1, 'b' => 2 }
+ * ```
+ */
+export declare class ValMap<K extends ValSchema<unknown, unknown>, V extends ValSchema<unknown, unknown>> extends ValSchema<Map<InferSchemaInput<K>, InferSchemaInput<V>>, Map<InferSchemaOutput<K>, InferSchemaOutput<V>>> {
+    readonly keySchema: K;
+    readonly valueSchema: V;
+    constructor(keySchema: K, valueSchema: V);
+}
+/**
+ * Schema for JavaScript Set objects.
+ *
+ * @template V - Value schema
+ *
+ * @example
+ * ```typescript
+ * const schema = v.set(v.string());
+ * schema.parse(new Set(['a', 'b', 'c'])); // Set { 'a', 'b', 'c' }
+ * ```
+ */
+export declare class ValSet<V extends ValSchema<unknown, unknown>> extends ValSchema<Set<InferSchemaInput<V>>, Set<InferSchemaOutput<V>>> {
+    readonly valueSchema: V;
+    constructor(valueSchema: V);
+}
+/**
+ * Allowed literal types.
+ */
+type LiteralValue = string | number | boolean | null | undefined;
+/**
+ * Schema for a single literal value.
+ *
+ * @template T - The literal type
+ *
+ * @example
+ * ```typescript
+ * const schema = v.literal('hello');
+ * schema.parse('hello'); // 'hello'
+ * schema.parse('world'); // throws
+ *
+ * type Hello = v.infer<typeof schema>; // 'hello'
+ * ```
+ */
+export declare class ValLiteralValue<T extends LiteralValue> extends ValSchema<T, T> {
+    readonly value: T;
+    constructor(literalValue: T);
+}
+/**
+ * Schema for enum values (one of a fixed set of string literals).
+ *
+ * @template T - Tuple of allowed string values
+ *
+ * @example
+ * ```typescript
+ * const RoleSchema = v.enum(['admin', 'user', 'guest']);
+ * RoleSchema.parse('admin'); // 'admin'
+ * RoleSchema.parse('other'); // throws
+ *
+ * type Role = v.infer<typeof RoleSchema>; // 'admin' | 'user' | 'guest'
+ * ```
+ */
+export declare class ValEnum<T extends readonly [string, ...string[]]> extends ValSchema<T[number], T[number]> {
+    readonly options: T;
+    /** Enum-like object mapping values to themselves */
+    readonly enum: {
+        [K in T[number]]: K;
+    };
+    constructor(values: T);
+}
+/**
+ * Gets the values of a TypeScript enum.
+ */
+type EnumLike = {
+    [k: string]: string | number;
+    [nu: number]: string;
+};
+/**
+ * Schema for TypeScript native enums.
+ *
+ * @template T - The enum type
+ *
+ * @example
+ * ```typescript
+ * enum Status { Active, Inactive }
+ * const schema = v.nativeEnum(Status);
+ * schema.parse(Status.Active); // 0
+ * schema.parse('Active');      // throws (numeric enum)
+ * ```
+ */
+export declare class ValNativeEnum<T extends EnumLike> extends ValSchema<T[keyof T], T[keyof T]> {
+    readonly enumObject: T;
+    constructor(enumObj: T);
+}
+/**
+ * Creates an object schema from a shape definition.
+ *
+ * @param shape - An object mapping property names to their schemas
+ * @returns A new object schema
+ *
+ * @example
+ * ```typescript
+ * const User = v.object({
+ *   name: v.string(),
+ *   age: v.number().int().positive(),
+ *   email: v.string().email().optional(),
+ * });
+ *
+ * type User = v.infer<typeof User>;
+ * // { name: string; age: number; email?: string }
+ *
+ * const user = User.parse({ name: 'Alice', age: 30 });
+ * ```
+ */
+export declare function object<T extends Shape>(shape: T): ValObject<T>;
+/**
+ * Creates a string schema.
+ *
+ * @returns A new string schema
+ *
+ * @example
+ * ```typescript
+ * const nameSchema = v.string();
+ * nameSchema.parse('Alice'); // 'Alice'
+ * nameSchema.parse(123);     // throws ValError
+ * ```
+ */
+export declare function string(): ValString;
+/**
+ * Creates a number schema.
+ *
+ * @returns A new number schema
+ *
+ * @example
+ * ```typescript
+ * const ageSchema = v.number();
+ * ageSchema.parse(25);     // 25
+ * ageSchema.parse('25');   // throws ValError
+ * ```
+ */
+export declare function number(): ValNumber;
+/**
+ * Creates a bigint schema.
+ *
+ * @returns A new bigint schema
+ *
+ * @example
+ * ```typescript
+ * const bigSchema = v.bigint();
+ * bigSchema.parse(123n);   // 123n
+ * bigSchema.parse(123);    // throws ValError
+ * ```
+ */
+export declare function bigint(): ValBigInt;
+/**
+ * Creates a boolean schema.
+ *
+ * @returns A new boolean schema
+ *
+ * @example
+ * ```typescript
+ * const flagSchema = v.boolean();
+ * flagSchema.parse(true);   // true
+ * flagSchema.parse('true'); // throws ValError
+ * ```
+ */
+declare function booleanFn(): ValBoolean;
+export { booleanFn as boolean };
+/**
+ * Creates a date schema.
+ *
+ * @returns A new date schema
+ *
+ * @example
+ * ```typescript
+ * const dateSchema = v.date();
+ * dateSchema.parse(new Date());        // Date object
+ * dateSchema.parse('2024-01-01');      // throws ValError
+ * ```
+ */
+export declare function date(): ValDate;
+/**
+ * Creates an undefined schema.
+ *
+ * @returns A new undefined schema
+ */
+declare function undefinedFn(): ValUndefined;
+export { undefinedFn as undefined };
+/**
+ * Creates a null schema.
+ *
+ * @returns A new null schema
+ */
+declare function nullFn(): ValNull;
+export { nullFn as null };
+/**
+ * Creates a void schema (alias for undefined).
+ *
+ * @returns A new void schema
+ */
+declare function voidFn(): ValVoid;
+export { voidFn as void };
+/**
+ * Creates an any schema.
+ *
+ * Use sparingly - prefer more specific schemas when possible.
+ *
+ * @returns A new any schema
+ */
+export declare function any(): ValAny;
+/**
+ * Creates an unknown schema.
+ *
+ * Unlike `any`, `unknown` requires type narrowing before use.
+ *
+ * @returns A new unknown schema
+ */
+export declare function unknown(): ValUnknown;
+/**
+ * Creates a never schema.
+ *
+ * Useful for exhaustive type checking and unreachable code paths.
+ *
+ * @returns A new never schema
+ */
+export declare function never(): ValNever;
+/**
+ * Creates a 32-bit signed integer schema.
+ *
+ * Range: -2,147,483,648 to 2,147,483,647
+ */
+export declare function int32(): ValInt32;
+/**
+ * Creates a 64-bit signed integer schema.
+ *
+ * Note: JavaScript numbers can only safely represent integers up to 2^53 - 1.
+ */
+export declare function int64(): ValInt64;
+/**
+ * Creates a 32-bit unsigned integer schema.
+ *
+ * Range: 0 to 4,294,967,295
+ */
+export declare function uint32(): ValUint32;
+/**
+ * Creates a 64-bit unsigned integer schema.
+ */
+export declare function uint64(): ValUint64;
+/**
+ * Creates a 32-bit floating point schema.
+ */
+export declare function float32(): ValFloat32;
+/**
+ * Creates a 64-bit floating point schema.
+ */
+export declare function float64(): ValFloat64;
+/**
+ * Creates an array schema for the given element type.
+ *
+ * @param element - The schema for array elements
+ * @returns A new array schema
+ *
+ * @example
+ * ```typescript
+ * const schema = v.array(v.string());
+ * schema.parse(['a', 'b', 'c']); // ['a', 'b', 'c']
+ *
+ * const withMin = v.array(v.number()).min(1);
+ * withMin.parse([]);    // throws
+ * withMin.parse([1, 2]); // [1, 2]
+ * ```
+ */
+export declare function array<S extends ValSchema<unknown, unknown>>(element: S): ValArray<S>;
+/**
+ * Creates a tuple schema with fixed element types.
+ *
+ * @param items - Array of schemas for each tuple element
+ * @returns A new tuple schema
+ *
+ * @example
+ * ```typescript
+ * const schema = v.tuple([v.string(), v.number()]);
+ * schema.parse(['hello', 42]); // ['hello', 42]
+ *
+ * const withRest = v.tuple([v.string()]).rest(v.number());
+ * withRest.parse(['hello', 1, 2, 3]); // ['hello', 1, 2, 3]
+ * ```
+ */
+export declare function tuple<T extends ReadonlyArray<ValSchema<unknown, unknown>>>(items: T): ValTuple<T, null>;
+/**
+ * Creates a union schema (one of multiple types).
+ *
+ * @param options - Array of schemas to union
+ * @returns A new union schema
+ *
+ * @example
+ * ```typescript
+ * const schema = v.union([v.string(), v.number()]);
+ * schema.parse('hello'); // 'hello'
+ * schema.parse(42);      // 42
+ * schema.parse(true);    // throws
+ * ```
+ */
+export declare function union<T extends readonly [ValSchema<unknown, unknown>, ...ValSchema<unknown, unknown>[]]>(options: T): ValUnion<T>;
+/**
+ * Creates a discriminated union schema (tagged union).
+ *
+ * Uses a discriminator property to efficiently match variants.
+ * Provides better error messages than regular unions.
+ *
+ * @param discriminator - The property name used to discriminate variants
+ * @param options - Array of object schemas with the discriminator
+ * @returns A new discriminated union schema
+ *
+ * @example
+ * ```typescript
+ * const schema = v.discriminatedUnion('type', [
+ *   v.object({ type: v.literal('a'), value: v.string() }),
+ *   v.object({ type: v.literal('b'), count: v.number() }),
+ * ]);
+ *
+ * schema.parse({ type: 'a', value: 'hello' }); // OK
+ * schema.parse({ type: 'b', count: 42 });      // OK
+ * schema.parse({ type: 'c' });                 // throws with helpful error
+ * ```
+ */
+export declare function discriminatedUnion<D extends string, T extends readonly [ValObject<Shape>, ...ValObject<Shape>[]]>(discriminator: D, options: T): ValDiscriminatedUnion<D, T>;
+/**
+ * Creates an intersection schema (all types must match).
+ *
+ * @param left - First schema
+ * @param right - Second schema
+ * @returns A new intersection schema
+ *
+ * @example
+ * ```typescript
+ * const A = v.object({ a: v.string() });
+ * const B = v.object({ b: v.number() });
+ * const AB = v.intersection(A, B);
+ *
+ * AB.parse({ a: 'hello', b: 42 }); // { a: 'hello', b: 42 }
+ * ```
+ */
+export declare function intersection<L extends ValSchema<unknown, unknown>, R extends ValSchema<unknown, unknown>>(left: L, right: R): ValIntersection<L, R>;
+/**
+ * Creates a record schema (object with string keys and typed values).
+ *
+ * @param valueSchema - Schema for all values (keys default to string)
+ * @returns A new record schema
+ *
+ * @example
+ * ```typescript
+ * // Record<string, string>
+ * const dict = v.record(v.string());
+ * dict.parse({ a: 'hello', b: 'world' }); // OK
+ *
+ * // Record<string, number>
+ * const counts = v.record(v.string(), v.number());
+ * counts.parse({ count: 42, score: 100 }); // OK
+ * ```
+ */
+export declare function record<V extends ValSchema<unknown, unknown>>(valueSchema: V): ValRecord<ValString, V>;
+export declare function record<K extends ValSchema<string, string>, V extends ValSchema<unknown, unknown>>(keySchema: K, valueSchema: V): ValRecord<K, V>;
+/**
+ * Creates a Map schema.
+ *
+ * @param keySchema - Schema for map keys
+ * @param valueSchema - Schema for map values
+ * @returns A new Map schema
+ *
+ * @example
+ * ```typescript
+ * const schema = v.map(v.string(), v.number());
+ * schema.parse(new Map([['a', 1], ['b', 2]])); // OK
+ * ```
+ */
+export declare function map<K extends ValSchema<unknown, unknown>, V extends ValSchema<unknown, unknown>>(keySchema: K, valueSchema: V): ValMap<K, V>;
+/**
+ * Creates a Set schema.
+ *
+ * @param valueSchema - Schema for set values
+ * @returns A new Set schema
+ *
+ * @example
+ * ```typescript
+ * const schema = v.set(v.string());
+ * schema.parse(new Set(['a', 'b', 'c'])); // OK
+ * ```
+ */
+export declare function set<V extends ValSchema<unknown, unknown>>(valueSchema: V): ValSet<V>;
+/**
+ * Creates a literal schema for a single value.
+ *
+ * @param value - The literal value to match
+ * @returns A new literal schema
+ *
+ * @example
+ * ```typescript
+ * const hello = v.literal('hello');
+ * hello.parse('hello'); // 'hello'
+ * hello.parse('world'); // throws
+ *
+ * const fortyTwo = v.literal(42);
+ * fortyTwo.parse(42);   // 42
+ *
+ * type Hello = v.infer<typeof hello>; // 'hello'
+ * ```
+ */
+export declare function literal<T extends string | number | boolean | null | undefined>(value: T): ValLiteralValue<T>;
+/**
+ * Creates an enum schema for a fixed set of string values.
+ *
+ * @param values - Tuple of allowed string values
+ * @returns A new enum schema with an `enum` property
+ *
+ * @example
+ * ```typescript
+ * const Role = v.enum(['admin', 'user', 'guest']);
+ * Role.parse('admin'); // 'admin'
+ * Role.parse('other'); // throws
+ *
+ * type Role = v.infer<typeof Role>; // 'admin' | 'user' | 'guest'
+ *
+ * // Access values like an enum
+ * Role.enum.admin; // 'admin'
+ * ```
+ */
+declare function enumFn<T extends readonly [string, ...string[]]>(values: T): ValEnum<T>;
+export { enumFn as enum };
+/**
+ * Creates a schema for a TypeScript native enum.
+ *
+ * @param enumObject - The TypeScript enum object
+ * @returns A new native enum schema
+ *
+ * @example
+ * ```typescript
+ * enum Status { Active, Inactive }
+ * const schema = v.nativeEnum(Status);
+ *
+ * schema.parse(Status.Active);   // 0
+ * schema.parse(Status.Inactive); // 1
+ * schema.parse(2);               // throws
+ * ```
+ */
+export declare function nativeEnum<T extends EnumLike>(enumObject: T): ValNativeEnum<T>;
+/**
+ * Wraps an existing Standard Schema into a ValSchema.
+ *
+ * Useful for integrating schemas from other Standard Schema compliant libraries.
+ *
+ * @param schema - A Standard Schema compliant object
+ * @returns A ValSchema instance with parse/safeParse methods
+ *
+ * @example
+ * ```typescript
+ * import { StringSchema } from 'valrs';
+ *
+ * const wrapped = v.wrap(StringSchema);
+ * wrapped.parse('hello'); // 'hello'
+ * ```
+ */
+export declare function wrap<Input, Output>(schema: StandardSchemaV1<Input, Output> & {
+    '~standard': {
+        jsonSchema?: {
+            input: (options: {
+                target: string;
+            }) => Record<string, unknown>;
+            output: (options: {
+                target: string;
+            }) => Record<string, unknown>;
+        };
+    };
+}): ValSchema<Input, Output>;
+/**
+ * Preprocesses input before passing to the schema.
+ *
+ * Useful for coercing input types before validation.
+ *
+ * @param preprocessFn - Function to transform the raw input
+ * @param schema - Schema to validate after preprocessing
+ * @returns A new schema that preprocesses then validates
+ *
+ * @example
+ * ```typescript
+ * const schema = v.preprocess(
+ *   (val) => (typeof val === 'string' ? parseInt(val, 10) : val),
+ *   v.number()
+ * );
+ *
+ * schema.parse('42');  // 42
+ * schema.parse(42);    // 42
+ * ```
+ */
+export declare function preprocess<Input, Output>(preprocessFn: (value: unknown) => Input, schema: ValSchema<Input, Output>): ValPreprocessed<Input, Output>;
+/**
+ * Schema that coerces input to string using String().
+ */
+declare class ValCoerceString extends ValSchema<unknown, string> {
+    constructor();
+}
+/**
+ * Schema that coerces input to number using Number().
+ */
+declare class ValCoerceNumber extends ValSchema<unknown, number> {
+    constructor();
+}
+/**
+ * Schema that coerces input to boolean.
+ *
+ * Truthy values become true, falsy values become false.
+ */
+declare class ValCoerceBoolean extends ValSchema<unknown, boolean> {
+    constructor();
+}
+/**
+ * Schema that coerces input to bigint using BigInt().
+ */
+declare class ValCoerceBigInt extends ValSchema<unknown, bigint> {
+    constructor();
+}
+/**
+ * Schema that coerces input to Date using new Date().
+ */
+declare class ValCoerceDate extends ValSchema<unknown, Date> {
+    constructor();
+}
+/**
+ * Coercion schema builders.
+ *
+ * These schemas attempt to convert input values to the target type
+ * before validation. Similar to Zod's coerce namespace.
+ *
+ * @example
+ * ```typescript
+ * v.coerce.string().parse(42);       // '42'
+ * v.coerce.number().parse('42');     // 42
+ * v.coerce.boolean().parse(1);       // true
+ * v.coerce.date().parse('2024-01-01'); // Date object
+ * ```
+ */
+export declare const coerce: {
+    /**
+     * Coerces any value to string using String().
+     */
+    readonly string: () => ValCoerceString;
+    /**
+     * Coerces any value to number using Number().
+     * Fails if the result is NaN.
+     */
+    readonly number: () => ValCoerceNumber;
+    /**
+     * Coerces any value to boolean using Boolean().
+     */
+    readonly boolean: () => ValCoerceBoolean;
+    /**
+     * Coerces any value to bigint using BigInt().
+     * Fails if the value cannot be converted.
+     */
+    readonly bigint: () => ValCoerceBigInt;
+    /**
+     * Coerces any value to Date using new Date().
+     * Fails if the result is an Invalid Date.
+     */
+    readonly date: () => ValCoerceDate;
+};
+export { stream, streamLines, createMockStream, createChunkedStream };
+/**
+ * The main valrs namespace, providing a Zod-compatible API.
+ *
+ * @example
+ * ```typescript
+ * import { v } from 'valrs';
+ *
+ * const schema = v.string();
+ * schema.parse('hello');
+ *
+ * type MyType = v.infer<typeof schema>;
+ * ```
+ */
+export declare const v: {
+    readonly string: typeof string;
+    readonly number: typeof number;
+    readonly bigint: typeof bigint;
+    readonly boolean: typeof booleanFn;
+    readonly date: typeof date;
+    readonly undefined: typeof undefinedFn;
+    readonly null: typeof nullFn;
+    readonly void: typeof voidFn;
+    readonly any: typeof any;
+    readonly unknown: typeof unknown;
+    readonly never: typeof never;
+    readonly object: typeof object;
+    readonly array: typeof array;
+    readonly tuple: typeof tuple;
+    readonly union: typeof union;
+    readonly discriminatedUnion: typeof discriminatedUnion;
+    readonly intersection: typeof intersection;
+    readonly record: typeof record;
+    readonly map: typeof map;
+    readonly set: typeof set;
+    readonly literal: typeof literal;
+    readonly enum: typeof enumFn;
+    readonly nativeEnum: typeof nativeEnum;
+    readonly int32: typeof int32;
+    readonly int64: typeof int64;
+    readonly uint32: typeof uint32;
+    readonly uint64: typeof uint64;
+    readonly float32: typeof float32;
+    readonly float64: typeof float64;
+    readonly preprocess: typeof preprocess;
+    readonly coerce: {
+        /**
+         * Coerces any value to string using String().
+         */
+        readonly string: () => ValCoerceString;
+        /**
+         * Coerces any value to number using Number().
+         * Fails if the result is NaN.
+         */
+        readonly number: () => ValCoerceNumber;
+        /**
+         * Coerces any value to boolean using Boolean().
+         */
+        readonly boolean: () => ValCoerceBoolean;
+        /**
+         * Coerces any value to bigint using BigInt().
+         * Fails if the value cannot be converted.
+         */
+        readonly bigint: () => ValCoerceBigInt;
+        /**
+         * Coerces any value to Date using new Date().
+         * Fails if the result is an Invalid Date.
+         */
+        readonly date: () => ValCoerceDate;
+    };
+    readonly wrap: typeof wrap;
+    readonly stream: typeof stream;
+    readonly streamLines: typeof streamLines;
+    readonly createMockStream: typeof createMockStream;
+    readonly createChunkedStream: typeof createChunkedStream;
+    readonly setErrorMap: typeof setErrorMapFn;
+    readonly getErrorMap: typeof getErrorMapFn;
+    readonly resetErrorMap: typeof resetErrorMapFn;
+};
+export default v;
+//# sourceMappingURL=v.d.ts.map