Variable Validator

Type Declaration

• any: () => Validator<any>

  Accepts any input value without validation.

• array: <T>(
      inner: Validator<T>,
      options?: { max?: number; min?: number },
  ) => Validator<T[]>

  Validates an array and each of its items.

• boolean: () => Validator<boolean>

  Validates a boolean value.

• custom: {
      <T>(
          predicate: (value: unknown) => value is T,
          message?: string,
          code?: string,
      ): Validator<T>;
      <T = unknown>(
          predicate: (value: unknown) => boolean,
          message?: string,
          code?: string,
      ): Validator<T>;
  }

  Validates a value using a custom predicate.

• enum: <const T extends readonly string[]>(values: T) => Validator<T[number]>

  Validates one of the provided string literal values.

• literal: <T extends string | number | boolean | null>(expected: T) => Validator<T>

  Validates a literal value.

• nullable: <T>(inner: Validator<T>) => Validator<T | null>

  Makes another validator nullable.

• number: (
      options?: {
          finite?: boolean;
          integer?: boolean;
          max?: number;
          min?: number;
      },
  ) => Validator<number>

  Validates a number value.

• object: <S extends SchemaShape, U extends UnknownKeyBehavior = "strip">(
      schema: S,
      options?: ObjectOptions<U>,
  ) => Validator<InferObjectShape<S, U>>

  Validates an object against a schema shape.

• optional: <T>(inner: Validator<T>) => Validator<T | undefined>

  Makes another validator optional.

• parse: <T>(validator: Validator<T>, value: unknown) => T

  Runs a validator and throws SchemaValidationError on failure.

• parseFormData: <T>(validator: Validator<T>, value: FormData) => T

  Runs a validator against a FormData payload and throws on failure. Repeated keys are exposed as arrays in insertion order.

• parseURLSearchParams: <T>(
      validator: Validator<T>,
      value: URLSearchParams | { searchParams: URLSearchParams },
  ) => T

  Runs a validator on a URL or URLSearchParams object and throws SchemaValidationError on failure.

• record: <T>(
      valueValidator: Validator<T>,
      options?: { key?: Validator<string> },
  ) => Validator<Record<string, T>>

  Validates a plain object record.

• refine: <T>(
      base: Validator<T>,
      predicate: (value: T) => boolean,
      message: string,
      code?: string,
  ) => Validator<T>

  Adds a custom predicate to an existing validator.

• safeParse: <T>(validator: Validator<T>, value: unknown) => ValidationResult<T>

  Runs a validator and returns a result object instead of throwing.

• safeParseFormData: <T>(validator: Validator<T>, value: FormData) => ValidationResult<T>

  Runs a validator against a FormData payload and returns a result object. Repeated keys are exposed as arrays in insertion order.

• safeParseURLSearchParams: <T>(
      validator: Validator<T>,
      value: URLSearchParams | { searchParams: URLSearchParams },
  ) => ValidationResult<T>

  Runs a validator on a URL or URLSearchParams object and returns a result object. Repeated keys are exposed as arrays in insertion order.

• string: (
      options?: {
          max?: number;
          min?: number;
          non_empty?: boolean;
          pattern?: RegExp;
          trim?: boolean;
      },
  ) => Validator<string>

  Validates a string value.

• transform: <T, U>(
      base: Validator<T>,
      mapper: (value: T) => U,
      message?: string,
      code?: string,
  ) => Validator<U>

  Maps a validated value into a new output type.

• tuple: <const T extends readonly [Validator<any>, Validator<any>]>(
      shape: T,
  ) => Validator<InferTupleShape<T>>

  Validates a tuple with a fixed number of items and validators.

• union: {
      <const T extends UnionShape>(
          validators: T,
      ): Validator<InferValidator<T[number]>>;
      <const T extends UnionShape>(
          ...validators: T,
      ): Validator<InferValidator<T[number]>>;
  }

  Validates a value against either of two validators.

• withDefault: <T>(inner: Validator<T>, fallback: T) => Validator<T>

  Applies a fallback value when the input is undefined.