ArrayOfValidator

Extends Validator<T[]>.

class ArrayOfValidator<T> extends Validator<T[]> {}

Constructs a new instance of the ArrayOfValidator class

Validatable<T>

Properties

readonly itemValidator: Validatable<T>

readonly validateUsingKnownGoodVersionFn?:
  | undefined
  | ValidatorUsingKnownGoodVersionFn<T, T>

readonly validationFn: ValidatorFn<T>

Methods

Refine this validation with an additional check that doesn't change the resulting value.

check(name: string, checkFn: (value: T) => void): Validator<T>

const numberLessThan10Validator = T.number.check((value) => {
  if (value >= 10) {
    throw new ValidationError(`Expected number less than 10, got ${value}`)
  }
})

string

(value: T) => void

Validator<T>

Checks that the passed value is of the correct type.

isValid(value: unknown): value is T

unknown

value is T

lengthGreaterThan1(): Validator<T[]>

nonEmpty(): Validator<T[]>

Returns a new validator that also accepts null or undefined. The resulting value will always be null.

nullable(): Validator<null | T>

Returns a new validator that also accepts null or undefined. The resulting value will always be null.

optional(): Validator<T | undefined>

Refine this validation to a new type. The passed-in validation function should throw an error if the value can't be converted to the new type, or return the new type otherwise.

refine<U>(otherValidationFn: (value: T) => U): Validator<U>

(value: T) => U

Validator<U>

Asserts that the passed value is of the correct type and returns it. The returned value is guaranteed to be referentially equal to the passed value.

validate(value: unknown): T

unknown

T

validateUsingKnownGoodVersion(knownGoodValue: T, newValue: unknown): T

T

unknown

T