Runtime type validation for JavaScript and TypeScript programs.

This library bring the benefits of TypeScript's type system to runtime code. By declaring types using runtime constructs, it is possible to add an extra level of runtime type safety that static checking alone cannot provide. For example:

• ensure that a parsed JSON string produces a value that conforms to an expected schema
• verify that a HTTP request body conforms to an expected schema
• ensure that a HTTP response body does not send additional properties other that those intended for the client

There is no need to declare any type twice (i.e., once for JS and once TS), since the TypeScript type can be inferred from the example property of any given TypeInfo value.

npm install rtti

import {t} from 'rtti';

const myType = t.union(
    t.unit('foo'),
    t.unit('bar')
);

// prints: "foo" | "bar"
console.log(myType.toString());

// prints: true
console.log(myType.isValid('foo'));

// prints: false
console.log(myType.isValid('baz'));

// prints: {
//     isValid: false,
//     errors: [
//         {path: '^', message: 'The value "baz" does not conform to the union type'}
//     ]
// }
console.log(myType.check('baz'));

// TypeScript only - static type inference:
type MyType = typeof myType.example; // type MyType = "foo" | "bar"

NOTE: The v0.4 API is deprecated but still supported.

Construct a TypeInfo instance that matches a particular set of runtime values.

Ensures the given value matches the given type, otherwise throws an error. The error object has an errors property containing details about the validation error(s).

Returns a list of descriptive validation errors explaining why the given value does not match the given type.

An example value that conforms to the given TypeInfo type. The TypeScript type can be inferred from this property.

Returns true if the given value matches the given type, or false otherwise.

Returns a copy of the given value, but where any properties not declared in type have been removed.

Returns a JSON schema representation of the given type.

Returns a descriptive string for the given type.

An object used by the RTTI library to describes a set of matching runtime values. These objects may be created using the t.<kind> syntax. See the following table for examples.