$ npm install typeboximport Type from 'typebox'
const T = Type.Object({ // const T = {
x: Type.Number(), // type: 'object',
y: Type.Number(), // required: ['x', 'y', 'z'],
z: Type.Number() // properties: {
}) // x: { type: 'number' },
// y: { type: 'number' },
// z: { type: 'number' }
// }
// }
type T = Type.Static<typeof T> // type T = {
// x: number,
// y: number,
// z: number
// }TypeBox is a runtime type system that creates in-memory Json Schema objects that infer as TypeScript types. The schematics produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type system that can be statically checked by TypeScript and validated at runtime using standard Json Schema.
This library is designed to allow Json Schema to compose similar to how types compose within TypeScript's type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
License: MIT
If upgrading from @sinclair/typebox refer to the 1.0 migration guide at the following URL.
TypeBox includes many functions to create Json Schema types. Each function returns a small Json Schema fragment that corresponds to a TypeScript type. TypeBox uses function composition to combine schema fragments into more complex types. It provides a set of functions that are used to model Json Schema schematics as well as a set of functions that model constructs native to JavaScript and TypeScript.
The following creates a Json Schema type and infers with Static.
import Type from 'typebox'
const T = Type.Object({ // const T = {
x: Type.Number(), // type: 'object',
y: Type.Number(), // required: ['x', 'y', 'z'],
z: Type.Number() // properties: {
}) // x: { type: 'number' },
// y: { type: 'number' },
// z: { type: 'number' }
// }
// }
type T = Type.Static<typeof T> // type T = {
// x: number,
// y: number,
// z: number
// }Schema options can be passed on the last argument of any given type.
const T = Type.String({ // const T = {
format: 'email' // type: 'string',
}) // format: 'email'
// }
const S = Type.Number({ // const S = {
minimum: 0, // type: 'number',
maximum: 100 // minimum: 0,
}) // maximum: 100
// }The Value module provides functions that perform typed operations on JavaScript values. It includes functions such as Check, Parse, Clone, Encode, Decode and as well as advanced functions to perform structural Diff and Patch on dynamic JavaScript values.
import Value from 'typebox/value'The following uses the Value module to Parse a value.
const T = Type.Object({
x: Type.Number(),
y: Type.Number(),
z: Type.Number()
})
const A = Value.Parse(T, { // const A: {
x: 1, // x: number,
y: 0, // y: number,
z: 0 // z: number
}) // } = ...The Compile module is a high-performance JIT compiler that transforms types into efficient runtime validators. The compiler is optimized for both fast compilation and validation.
import { Compile } from 'typebox/compile' The following uses the compiler to Compile and Parse a value.
const C = Compile(Type.Object({ // const C: Validator<{}, TObject<{
x: Type.Number(), // x: TNumber,
y: Type.Number(), // y: TNumber,
z: Type.Number() // z: TNumber
})) // }>>
const A = C.Parse({ // const A: {
x: 0, // x: number,
y: 1, // y: number,
z: 0 // z: number
}) // } = ...TypeBox is built upon a high-performance validation infrastructure that supports the direct compilation and inference of Json Schema schematics. TypeBox implements Draft 3 to 2020-12 and is compliance tested via the official Json Schema Test Suite. It offers high-performance JIT compilation with automatic fallback to dynamic checking in JIT restricted environments.
The following compiles Json Schema. Type inference is supported.
const C = Compile({
type: 'object',
required: ['x', 'y', 'z'],
properties: {
x: { type: 'number' },
y: { type: 'number' },
z: { type: 'number' }
}
})
const A = C.Parse({ // const A: {
x: 0, // x: number,
y: 0, // y: number,
z: 1 // z: number
}) // } = ...It can also be used to accelerate remote libraries via Json Schema translation.
const C = Compile(x.toJsonSchema(x.object({
x: x.number(),
y: x.number(),
z: x.number()
})))
const A = C.Check(...) // high performance runtime checkingDocumentation | Example 1 | Example 2
TypeBox includes a TypeScript scripting engine able to parse TypeScript types directly into Json Schema. The engine uses symmetric runtime and type-level parsing and returns typed safe schematics from TypeScript types (including computed types). The engine is designed for TypeScript 7 native compiler but is supported in TypeScript 5 and above.
// Scripted Type
const T = Type.Script(`{
x: number,
y: string,
z: boolean
}`) // const T: TObject<{
// x: TNumber,
// y: TString,
// z: TBoolean
// }>
// Json Schema Introspection
T.type // 'object'
T.required // ['x', 'y', 'z']
T.properties // { x: ..., y: ..., z: ... }
// Scripted Type (Computed)
const S = Type.Script({ T }, `{
[K in keyof T]: T[K] | null
}`) // const S: TObject<{
// x: TUnion<[TNumber, TNull]>,
// y: TUnion<[TString, TNull]>,
// z: TUnion<[TBoolean, TNull]>
// }>
// Standard Inference
type S = Type.Static<typeof S> // type S = {
// x: number | null,
// y: string | null,
// z: boolean | null
// }TypeBox is open to community contribution. Please ensure you submit an issue before submitting a pull request. The TypeBox project prefers open community discussion before accepting new features.
