T

Properties

Validation that accepts any value. Generally this should be avoided, but you can use it as an escape hatch if you want to work without validations for e.g. a prototype.

any: Validator<any>

Validates that a value is an array. To check the contents of the array, use T.arrayOf.

array: Validator<unknown[]>

Validates that a value is a bigint.

bigint: Validator<bigint>

Validates that a value is boolean.

boolean: Validator<boolean>

Validates an http(s) url

httpUrl: Validator<string>

Validates that a value is an IndexKey.

indexKey: Validator<IndexKey>

Fails if number is not an integer

integer: Validator<number>

Validate that a value is valid JSON.

jsonValue: Validator<JsonValue>

Validates that a value is a url safe to use as a link.

linkUrl: Validator<string>

Fails if value <= 0 and is not an integer

nonZeroInteger: Validator<number>

Fails if value <= 0

nonZeroNumber: Validator<number>

Validates that a value is a finite non-NaN number.

number: Validator<number>

Fails if value < 0 and is not an integer

positiveInteger: Validator<number>

Fails if value < 0

positiveNumber: Validator<number>

Validates that a valid is a url safe to load as an asset.

srcUrl: Validator<string>

Validates that a value is a string.

string: Validator<string>

Validation that accepts any value. Useful as a starting point for building your own custom validations.

unknown: Validator<unknown>

unknownObject: Validator<Record<string, unknown>>

Methods

Validates that a value is an array whose contents matches the passed-in validator.

function arrayOf<T>(itemValidator: Validatable<T>): ArrayOfValidator<T>

Validatable<T>

ArrayOfValidator<T>

Validation that an option is a dict with particular keys and values.

function dict<Key extends string, Value>(
  keyValidator: Validatable<Key>,
  valueValidator: Validatable<Value>
): DictValidator<Key, Value>

Validatable<Key>

Validatable<Value>

DictValidator<Key, Value>

Validate an object has a particular shape.

function jsonDict(): DictValidator<string, JsonValue>

Validates that a value matches another that was passed in.

function literal<T extends boolean | number | string>(
  expectedValue: T
): Validator<T>

const trueValidator = T.literal(true)

T

Validator<T>

function literalEnum<const Values extends readonly unknown[]>(
  ...values: Values
): Validator<Values[number]>

Values

Validator<Values[number]>

A named object with an ID. Errors will be reported as being part of the object with the given name.

function model<
  T extends {
    readonly id: string
  },
>(name: string, validator: Validatable<T>): Validator<T>

string

Validatable<T>

Validator<T>

function nullable<T>(validator: Validatable<T>): Validator<null | T>

Validatable<T>

Validator<null | T>

Validate an object has a particular shape.

function object<Shape extends object>(config: {
  readonly [K in keyof Shape]: Validatable<Shape[K]>
}): ObjectValidator<
  Expand<
    {
      [P in ExtractRequiredKeys<Shape>]: Shape[P]
    } & {
      [P in ExtractOptionalKeys<Shape>]?: Shape[P]
    }
  >
>

{
  readonly [K in keyof Shape]: Validatable<Shape[K]>
}

ObjectValidator<
  Expand<
    {
      [P in ExtractRequiredKeys<Shape>]: Shape[P]
    } & {
      [P in ExtractOptionalKeys<Shape>]?: Shape[P]
    }
  >
>

function optional<T>(validator: Validatable<T>): Validator<T | undefined>

Validatable<T>

Validator<T | undefined>

function setEnum<T>(values: ReadonlySet<T>): Validator<T>

ReadonlySet<T>

Validator<T>

Validate a union of several object types. Each object must have a property matching key which should be a unique string.

function union<
  Key extends string,
  Config extends UnionValidatorConfig<Key, Config>,
>(key: Key, config: Config): UnionValidator<Key, Config>

const catValidator = T.object({ kind: T.literal('cat'), meow: T.boolean })
const dogValidator = T.object({ kind: T.literal('dog'), bark: T.boolean })
const animalValidator = T.union('kind', {
  cat: catValidator,
  dog: dogValidator,
})

Key

Config

UnionValidator<Key, Config>