DictValidator

Extends Validator<Record<Key, Value>>.

class DictValidator<Key extends string, Value> extends Validator<
  Record<Key, Value>
> {}

Constructs a new instance of the DictValidator class

Validatable<Key>

Validatable<Value>

Properties

readonly keyValidator: Validatable<Key>

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

readonly validationFn: ValidatorFn<T>

readonly valueValidator: Validatable<Value>

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

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