type infer<T extends ValSchema<unknown, unknown>> =
  T extends ValSchema<unknown, infer O> ? O : never;

import { v } from 'valrs';
 
const userSchema = v.object({
  name: v.string(),
  age: v.number(),
  email: v.string().email(),
});
 
// Infer the output type
type User = v.infer<typeof userSchema>;
// { name: string; age: number; email: string }
 
// Works with all schema types
const arraySchema = v.array(v.string());
type StringArray = v.infer<typeof arraySchema>; // string[]
 
const unionSchema = v.union([v.string(), v.number()]);
type StringOrNumber = v.infer<typeof unionSchema>; // string | number

type input<T extends ValSchema<unknown, unknown>> =
  T extends ValSchema<infer I, unknown> ? I : never;

import { v } from 'valrs';
 
// With coercion, input differs from output
const schema = v.coerce.number();
type Input = v.input<typeof schema>;   // unknown
type Output = v.output<typeof schema>; // number
 
// With transforms
const dateSchema = v.string().transform((s) => new Date(s));
type DateInput = v.input<typeof dateSchema>;  // string
type DateOutput = v.output<typeof dateSchema>; // Date

type output<T extends ValSchema<unknown, unknown>> = Infer<T>;

import { v } from 'valrs';
 
const schema = v.string().transform((s) => s.length);
 
type Input = v.input<typeof schema>;   // string
type Output = v.output<typeof schema>; // number (same as v.infer)

type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError;

import { v } from 'valrs';
 
const schema = v.string().min(3);
const result = schema.safeParse(input);
 
if (result.success) {
  // TypeScript knows result.data is string
  console.log(result.data.toUpperCase());
} else {
  // TypeScript knows result.error is ValError
  console.log(result.error.issues);
}

interface SafeParseSuccess<T> {
  readonly success: true;
  readonly data: T;
  readonly error?: undefined;
}

interface SafeParseError {
  readonly success: false;
  readonly error: ValError;
  readonly data?: undefined;
}

import { v, isSafeParseSuccess, isSafeParseError } from 'valrs';
 
const result = v.string().safeParse(input);
 
// Using type guards
if (isSafeParseSuccess(result)) {
  console.log(result.data);
}
 
if (isSafeParseError(result)) {
  console.log(result.error.message);
}

class ValError extends Error {
  readonly name: 'ValError';
  readonly issues: ReadonlyArray<ValIssue>;
 
  constructor(issues: ReadonlyArray<ValidationIssue>);
 
  // Instance methods
  get firstError(): ValIssue | undefined;
  hasErrorAt(path: ReadonlyArray<string | number>): boolean;
  errorsAt(path: ReadonlyArray<string | number>): ReadonlyArray<ValIssue>;
  format<T = unknown>(): FormattedError<T>;
  flatten<T = unknown>(): FlattenedError<T>;
  addIssue(issue: ValIssue): ValError;
  addIssues(issues: ReadonlyArray<ValIssue>): ValError;
 
  // Static methods
  static fromValIssues(issues: ReadonlyArray<ValIssue>): ValError;
  static isValError(value: unknown): value is ValError;
}

import { v, ValError } from 'valrs';
 
try {
  v.string().parse(123);
} catch (error) {
  if (error instanceof ValError) {
    // Access all issues
    console.log(error.issues);
    // [{ code: 'invalid_type', path: [], message: '...', expected: 'string', received: 'number' }]
 
    // Get first error
    console.log(error.firstError?.message);
 
    // Check for errors at a specific path
    if (error.hasErrorAt(['user', 'email'])) {
      const emailErrors = error.errorsAt(['user', 'email']);
    }
 
    // Format as nested object
    console.log(error.format());
    // { _errors: ['Expected string, received number'] }
 
    // Flatten for form handling
    console.log(error.flatten());
    // { formErrors: ['Expected string, received number'], fieldErrors: {} }
  }
}

type ValIssue =
  | InvalidTypeIssue
  | InvalidLiteralIssue
  | CustomIssue
  | InvalidUnionIssue
  | InvalidUnionDiscriminatorIssue
  | InvalidEnumValueIssue
  | UnrecognizedKeysIssue
  | InvalidArgumentsIssue
  | InvalidReturnTypeIssue
  | InvalidDateIssue
  | InvalidStringIssue
  | TooSmallIssue
  | TooBigIssue
  | InvalidIntersectionTypesIssue
  | NotMultipleOfIssue
  | NotFiniteIssue;

type ValIssueCode =
  | 'invalid_type'
  | 'invalid_literal'
  | 'custom'
  | 'invalid_union'
  | 'invalid_union_discriminator'
  | 'invalid_enum_value'
  | 'unrecognized_keys'
  | 'invalid_arguments'
  | 'invalid_return_type'
  | 'invalid_date'
  | 'invalid_string'
  | 'too_small'
  | 'too_big'
  | 'invalid_intersection_types'
  | 'not_multiple_of'
  | 'not_finite';

interface ValIssueBase {
  readonly code: ValIssueCode;
  readonly path: ReadonlyArray<string | number>;
  readonly message: string;
}

interface InvalidTypeIssue extends ValIssueBase {
  readonly code: 'invalid_type';
  readonly expected: string;
  readonly received: string;
}

// When parsing: v.string().parse(123)
{
  code: 'invalid_type',
  expected: 'string',
  received: 'number',
  path: [],
  message: 'Expected string, received number'
}

interface TooSmallIssue extends ValIssueBase {
  readonly code: 'too_small';
  readonly type: SizeType;
  readonly minimum: number | bigint;
  readonly inclusive: boolean;
  readonly exact?: boolean | undefined;
}
 
type SizeType = 'string' | 'number' | 'array' | 'set' | 'date' | 'bigint';

// When parsing: v.string().min(5).parse('hi')
{
  code: 'too_small',
  type: 'string',
  minimum: 5,
  inclusive: true,
  path: [],
  message: 'String must be at least 5 characters'
}

interface TooBigIssue extends ValIssueBase {
  readonly code: 'too_big';
  readonly type: SizeType;
  readonly maximum: number | bigint;
  readonly inclusive: boolean;
  readonly exact?: boolean | undefined;
}

// When parsing: v.number().max(100).parse(150)
{
  code: 'too_big',
  type: 'number',
  maximum: 100,
  inclusive: true,
  path: [],
  message: 'Value must be at most 100'
}

interface InvalidStringIssue extends ValIssueBase {
  readonly code: 'invalid_string';
  readonly validation:
    | StringValidation
    | { readonly includes: string; readonly position?: number }
    | { readonly startsWith: string }
    | { readonly endsWith: string };
}
 
type StringValidation =
  | 'email'
  | 'url'
  | 'emoji'
  | 'uuid'
  | 'cuid'
  | 'cuid2'
  | 'ulid'
  | 'regex'
  | 'datetime'
  | 'ip'
  | 'base64';

// When parsing: v.string().email().parse('not-an-email')
{
  code: 'invalid_string',
  validation: 'email',
  path: [],
  message: 'Invalid email'
}

interface InvalidEnumValueIssue extends ValIssueBase {
  readonly code: 'invalid_enum_value';
  readonly options: ReadonlyArray<string | number>;
  readonly received: unknown;
}

// When parsing: v.enum(['red', 'green', 'blue']).parse('yellow')
{
  code: 'invalid_enum_value',
  options: ['red', 'green', 'blue'],
  received: 'yellow',
  path: [],
  message: 'Invalid enum value. Expected "red" | "green" | "blue", received "yellow"'
}

interface InvalidUnionIssue extends ValIssueBase {
  readonly code: 'invalid_union';
  readonly unionErrors: ReadonlyArray<ValError>;
}

interface InvalidUnionDiscriminatorIssue extends ValIssueBase {
  readonly code: 'invalid_union_discriminator';
  readonly options: ReadonlyArray<string | number>;
}

interface UnrecognizedKeysIssue extends ValIssueBase {
  readonly code: 'unrecognized_keys';
  readonly keys: ReadonlyArray<string>;
}

// When parsing: v.object({ name: v.string() }).strict().parse({ name: 'Alice', extra: true })
{
  code: 'unrecognized_keys',
  keys: ['extra'],
  path: [],
  message: "Unrecognized key(s) in object: 'extra'"
}

interface InvalidLiteralIssue extends ValIssueBase {
  readonly code: 'invalid_literal';
  readonly expected: unknown;
  readonly received: unknown;
}

interface CustomIssue extends ValIssueBase {
  readonly code: 'custom';
  readonly params?: Record<string, unknown> | undefined;
}

interface NotMultipleOfIssue extends ValIssueBase {
  readonly code: 'not_multiple_of';
  readonly multipleOf: number;
}

interface NotFiniteIssue extends ValIssueBase {
  readonly code: 'not_finite';
}

interface InvalidDateIssue extends ValIssueBase {
  readonly code: 'invalid_date';
}

interface InvalidArgumentsIssue extends ValIssueBase {
  readonly code: 'invalid_arguments';
  readonly argumentsError: ValError;
}

interface InvalidReturnTypeIssue extends ValIssueBase {
  readonly code: 'invalid_return_type';
  readonly returnTypeError: ValError;
}

interface InvalidIntersectionTypesIssue extends ValIssueBase {
  readonly code: 'invalid_intersection_types';
}

type FormattedError<T = unknown> = {
  _errors: string[];
} & (T extends object
  ? { [K in keyof T]?: FormattedError<T[K]> }
  : unknown);

const error = new ValError([
  { message: 'Required', path: ['user', 'name'], code: 'custom' },
  { message: 'Invalid email', path: ['user', 'email'], code: 'custom' },
]);
 
error.format();
// {
//   _errors: [],
//   user: {
//     _errors: [],
//     name: { _errors: ['Required'] },
//     email: { _errors: ['Invalid email'] },
//   }
// }

interface FlattenedError<T = unknown> {
  formErrors: string[];
  fieldErrors: T extends object
    ? { [K in keyof T]?: string[] }
    : { [key: string]: string[] };
}

const error = new ValError([
  { message: 'Required', path: ['name'], code: 'custom' },
  { message: 'Form-level error', path: [], code: 'custom' },
]);
 
error.flatten();
// {
//   formErrors: ['Form-level error'],
//   fieldErrors: {
//     name: ['Required'],
//   }
// }

type ErrorMapFn = (issue: ValIssue, ctx: ErrorMapContext) => string;

interface ErrorMapContext {
  readonly defaultError: string;
  readonly data: unknown;
}

import { v } from 'valrs';
 
v.setErrorMap((issue, ctx) => {
  if (issue.code === 'invalid_type') {
    return `Expected ${issue.expected}, got ${issue.received}`;
  }
  if (issue.code === 'too_small' && issue.type === 'string') {
    return `Must be at least ${issue.minimum} characters`;
  }
  return ctx.defaultError;
});

interface StandardSchemaV1<Input = unknown, Output = Input> {
  readonly '~standard': {
    readonly version: 1;
    readonly vendor: string;
    readonly validate: (
      value: unknown
    ) => ValidationResult<Output> | Promise<ValidationResult<Output>>;
  };
}

interface StandardJSONSchemaV1<Input = unknown, Output = Input>
  extends StandardSchemaV1<Input, Output> {
  readonly '~standard': StandardSchemaV1<Input, Output>['~standard'] & {
    readonly jsonSchema: {
      readonly input: (options: JsonSchemaOptions) => Record<string, unknown>;
      readonly output: (options: JsonSchemaOptions) => Record<string, unknown>;
    };
  };
}

type ValidationResult<T> =
  | { readonly value: T; readonly issues?: undefined }
  | { readonly issues: ReadonlyArray<ValidationIssue>; readonly value?: undefined };

interface ValidationIssue {
  readonly message: string;
  readonly path?: ReadonlyArray<PathSegment>;
}

type PathSegment = string | number | { readonly key: string | number };

interface JsonSchemaOptions {
  readonly target: string;
}

type InferInput<T extends StandardSchemaV1> =
  T extends StandardSchemaV1<infer I, unknown> ? I : never;

import type { InferInput } from 'valrs';
import { StringSchema } from 'valrs';
 
type StringInput = InferInput<typeof StringSchema>;
// string

type InferOutput<T extends StandardSchemaV1> =
  T extends StandardSchemaV1<unknown, infer O> ? O : never;

import type { InferOutput } from 'valrs';
import { StringSchema } from 'valrs';
 
type StringOutput = InferOutput<typeof StringSchema>;
// string

import type {
  // Type inference
  Infer,
  infer,
  input,
  output,
 
  // SafeParse types
  SafeParseResult,
  SafeParseSuccess,
  SafeParseError,
 
  // Issue types
  ValIssueCode,
  ValIssueBase,
  ValIssue,
  InvalidTypeIssue,
  InvalidLiteralIssue,
  CustomIssue,
  InvalidUnionIssue,
  InvalidUnionDiscriminatorIssue,
  InvalidEnumValueIssue,
  UnrecognizedKeysIssue,
  InvalidArgumentsIssue,
  InvalidReturnTypeIssue,
  InvalidDateIssue,
  InvalidStringIssue,
  TooSmallIssue,
  TooBigIssue,
  InvalidIntersectionTypesIssue,
  NotMultipleOfIssue,
  NotFiniteIssue,
  SizeType,
  StringValidation,
 
  // Error formatting
  FormattedError,
  FlattenedError,
  ErrorMapFn,
  ErrorMapContext,
  SchemaErrorOptions,
 
  // Standard Schema types
  StandardSchemaV1,
  StandardJSONSchemaV1,
  ValidationResult,
  ValidationIssue,
  PathSegment,
  JsonSchemaOptions,
  InferInput,
  InferOutput,
} from 'valrs';
 
// ValError is a value export (class)
import { ValError } from 'valrs';