Skip to content

Latest commit

 

History

History
1529 lines (1223 loc) · 101 KB

readme.md

File metadata and controls

1529 lines (1223 loc) · 101 KB

TypeBox

JSON Schema Type Builder with Static Type Resolution for TypeScript



npm version Downloads Install Size License: MIT GitHub CI

Install

Npm

$ npm install @sinclair/typebox --save

Deno

import { Static, Type } from 'npm:@sinclair/typebox'

Esm

import { Static, Type } from 'https://esm.sh/@sinclair/typebox'

Example

import { Static, Type } from '@sinclair/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 = Static<typeof T>                            // type T = {
                                                     //   x: number,
                                                     //   y: number,
                                                     //   z: number
                                                     // }

Overview

TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.

This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire.

License MIT

Contents

Usage

The following shows general usage.

import { Static, Type } from '@sinclair/typebox'

//--------------------------------------------------------------------------------------------
//
// Let's say you have the following type ...
//
//--------------------------------------------------------------------------------------------

type T = {
  id: string,
  name: string,
  timestamp: number
}

//--------------------------------------------------------------------------------------------
//
// ... you can express this type in the following way.
//
//--------------------------------------------------------------------------------------------

const T = Type.Object({                              // const T = {
  id: Type.String(),                                 //   type: 'object',
  name: Type.String(),                               //   properties: { 
  timestamp: Type.Integer()                          //     id: { 
})                                                   //       type: 'string' 
                                                     //     },
                                                     //     name: { 
                                                     //       type: 'string' 
                                                     //     },
                                                     //     timestamp: { 
                                                     //       type: 'integer' 
                                                     //     }
                                                     //   }, 
                                                     //   required: [
                                                     //     'id',
                                                     //     'name',
                                                     //     'timestamp'
                                                     //   ]
                                                     // } 

//--------------------------------------------------------------------------------------------
//
// ... then infer back to the original static type this way.
//
//--------------------------------------------------------------------------------------------

type T = Static<typeof T>                            // type T = {
                                                     //   id: string,
                                                     //   name: string,
                                                     //   timestamp: number
                                                     // }

//--------------------------------------------------------------------------------------------
//
// ... then use the type both as JSON schema and as a TypeScript type.
//
//--------------------------------------------------------------------------------------------

import { Value } from '@sinclair/typebox/value'

function receive(value: T) {                         // ... as a Static Type

  if(Value.Check(T, value)) {                        // ... as a JSON Schema
  
    // ok...
  }
}

Types

TypeBox types are JSON schema fragments that can be composed into more complex types. Each fragment is structured such that a JSON schema compliant validator can runtime assert a value the same way TypeScript will statically assert a type. TypeBox provides a set of Standard types which are used create JSON schema compliant schematics as well as an Extended type set used to create schematics for constructs native to JavaScript.

Standard Types

The following table lists the Standard TypeBox types. These types are fully compatible with the JSON Schema Draft 6 specification.

┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
 TypeBox                         TypeScript                   JSON Schema                    
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Any()            type T = any                 const T = { }                  
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Unknown()        type T = unknown             const T = { }                  
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.String()         type T = string              const T = {                    
                                                                type: 'string'               
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Number()         type T = number              const T = {                    
                                                                type: 'number'               
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Integer()        type T = number              const T = {                    
                                                                type: 'integer'              
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Boolean()        type T = boolean             const T = {                    
                                                                type: 'boolean'              
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Null()           type T = null                const T = {                    
                                                                type: 'null'                 
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Literal(42)      type T = 42                  const T = {                    
                                                                const: 42,                   
                                                                type: 'number'               
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Array(           type T = number[]            const T = {                    
   Type.Number()                                                type: 'array',               
 )                                                              items: {                     
                                                                  type: 'number'             
                                                                }                            
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Object({         type T = {const T = {                    
   x: Type.Number(),               x: number,                   type: 'object',              
   y: Type.Number()                y: number                    required: ['x', 'y'], })                              }                              properties: {                
                                                                  x: {                       
                                                                    type: 'number'           
                                                                  },                         
                                                                  y: {                       
                                                                    type: 'number'           
                                                                  }                          
                                                                }                            
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Tuple([          type T = [number, number]    const T = {                    
   Type.Number(),                                               type: 'array',               
   Type.Number()                                                items: [{                    
 ])                                                                type: 'number'            
                                                                }, {                         
                                                                  type: 'number'             
                                                                }],                          
                                                                additionalItems: false,      
                                                                minItems: 2,                 
                                                                maxItems: 2                  
                                                              }                              
                                                                                             
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 enum Foo {                      enum Foo {                   const T = {                    
   A,A,                           anyOf: [{                    
   B                               B                              type: 'number', }                               }                                const: 0                   
                                                                }, { const T = Type.Enum(Foo)        type T = Foo                     type: 'number',            
                                                                  const: 1                   
                                                                }]                           
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.KeyOf(           type T = keyof {             const T = {                    
   Type.Object({                   x: number,                   anyOf: [{                    
     x: Type.Number(),             y: number                      type: 'string',            
     y: Type.Number()            }                                const: 'x'                 
   })                                                           }, {                         
 )                                                                type: 'string',            
                                                                  const: 'y'                 
                                                                }]                           
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Union([          type T = string | number     const T = {                    
   Type.String(),                                               anyOf: [{                    
   Type.Number()                                                   type: 'string'            
 ])                                                             }, {                         
                                                                   type: 'number'            
                                                                }]                           
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Intersect([      type T = {                   const T = {                    
   Type.Object({                   x: number                    allOf: [{                    
     x: Type.Number()            } & {                            type: 'object',   }),                             y: number                      required: ['x'],           
   Type.Object({}                                properties: {              
     y: Type.Number()                                               x: {                     
   ])                                                                 type: 'number'         
 ])                                                                 }                        
                                                                  }                          
                                                                }, {                         
                                                                  type: 'object',            |
                                                                  required: ['y'],           
                                                                  properties: {              
                                                                    y: {                     
                                                                      type: 'number'         
                                                                    }                        
                                                                  }                          
                                                                }]                           
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Composite([      type I = {                   const T = {                    
   Type.Object({                   x: number                    type: 'object',              
     x: Type.Number()            } & {                          required: ['x', 'y'],   }),                             y: number                    properties: {                
   Type.Object({}                                x: {                       
     y: Type.Number()                                               type: 'number'           
   })                            type T = {                       },                         
 ])                                [K in keyof I]: I[K]           y: {                       
                                 }                                  type: 'number'           
                                                                  }                          
                                                                }                            
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Never()          type T = never               const T = {                    
                                                                not: {}                      
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Not(            | type T = string              const T = {                    
|   Type.Union([                                                 allOf: [{                    
     Type.Literal('x'),                                           not: {                     
     Type.Literal('y'),                                             anyOf: [                 
     Type.Literal('z')                                                { const: 'x' },        
   ]),                                                                { const: 'y' },        
   Type.String()                                                      { const: 'z' }         
 )                                                                  ]                        
                                                                  }                          
                                                                }, {                         
                                                                  type: 'string'             
                                                                }]                           
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Extends(         type T =                     const T = {                    
   Type.String(),                 string extends number         const: false,                
   Type.Number(),                 true : false                  type: 'boolean'              
   Type.Literal(true),                                        }                              
   Type.Literal(false)                                                                       
 )                                                                                           
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Extract(         type T = Extract<            const T = {                    
   Type.Union([                    string | number,             type: 'string'               
     Type.String(),                string                     }                              
     Type.Number(),              >                                                           
   ]),                                                                                       
   Type.String()                                                                             
 )                                                                                           
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Exclude(         type T = Exclude<            const T = {                    
   Type.Union([                    string | number,             type: 'number'               
     Type.String(),                string                     }                              
     Type.Number(),              >                                                           
   ]),                                                                                       
   Type.String()                                                                             
 )                                                                                           
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const U = Type.Union([          type U = 'open' | 'close'    const T = {                    
   Type.Literal('open'),                                        type: 'string',              
   Type.Literal('close')         type T = `on${U}`              pattern: '^on(open|close)$'  
 ])                                                           }                              
                                                                                             
 const T = Type                                                                              
   .TemplateLiteral([                                                                        
      Type.Literal('on'),                                                                    
      U                                                                                      
   ])                                                                                        
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Record(          type T = Record<             const T = {                    
   Type.String(),                  string,                      type: 'object',              
   Type.Number()                   number                       patternProperties: {         
 )                               >                                '^.*$': {                  
                                                                    type: 'number'           
                                                                  }                          
                                                                }                            
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Partial(         type T = Partial<{           const T = {                    
   Type.Object({                   x: number,                   type: 'object',              
     x: Type.Number(),             y: number                    properties: {                
     y: Type.Number()           | }>                               x: {                       
   })                                                               type: 'number'           
 )                                                                },                         
                                                                  y: {                       
                                                                    type: 'number'           
                                                                  }                          
                                                                }                            
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Required(        type T = Required<{const T = {                    
   Type.Object({                   x?: number,                  type: 'object',              
     x: Type.Optional(             y?: number                   required: ['x', 'y'],        
       Type.Number()            | }>                             properties: {                
     ),                                                           x: {                       
     y: Type.Optional(                                              type: 'number'           
       Type.Number()                                              },                         
     )                                                            y: {                       
   })                                                               type: 'number'           
 )                                                                }                          
                                                                }                            
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Pick(            type T = Pick<{              const T = {                    
   Type.Object({                   x: number,                   type: 'object',              
     x: Type.Number(),             y: number                    required: ['x'],             
     y: Type.Number()            }, 'x'>                        properties: {                
   }), ['x']                    |                                  x: {                       
 )                                                                  type: 'number'           
                                                                  }                          
                                                                }                            
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Omit(            type T = Omit<{              const T = {                    
   Type.Object({                   x: number,                   type: 'object',              
     x: Type.Number(),             y: number                    required: ['y'],             
     y: Type.Number()            }, 'x'>                        properties: {                
   }), ['x']                    |                                  y: {                       
 )                                                                  type: 'number'           
                                                                  }                          
                                                                }                            
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Index(           type T = {                   const T = {                    
   Type.Object({                   x: number,                   type: 'number'               
     x: Type.Number(),             y: string                  }                              
     y: Type.String()            }['x']                                                      
   }), ['x']                                                                                 
 )                                                                                           
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const A = Type.Tuple([          type A = [0, 1]              const T = {                    
   Type.Literal(0),              type B = [2, 3]                type: 'array',               
   Type.Literal(1)               type T = [...A, ...B]          items: [                     
 ])                                                               { const: 0 },              
 const B = Type.Tuple([                                           { const: 1 },              
|   Type.Literal(2),                                               { const: 2 },              
|   Type.Literal(3)                                                { const: 3 }               
 ])                                                             ],                           
 const T = Type.Tuple([                                         additionalItems: false,      
|   ...Type.Rest(A),                                             minItems: 4,                 
|   ...Type.Test(B)                                              maxItems: 4                  
 ])                                                           }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Object({         type T = {const R = {                    
    x: Type.Number(),              x: number,                   $ref: 'T'                    
    y: Type.Number()               y: number                  }                              
 }, { $id: 'T' })               | }                                                           
                                                                                             
 const R = Type.Ref(T)           type R = T                                                  
                                                                                             
                                                                                             
                                                                                             
                                                                                             
└────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘

Extended Types

TypeBox provides several extended types that can be used to produce schematics for common JavaScript constructs. These types can not be used with standard JSON schema validators; but are useful to help frame schematics for RPC interfaces that may receive JSON validated data. Extended types are prefixed with the [Extended] doc comment for convenience. The following table lists the supported types.

┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
 TypeBox                         TypeScript                   Extended Schema                
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Constructor([    type T = new (               const T = {                    
   Type.String(),                 arg0: string,                 type: 'object',              
   Type.Number()                  arg1: number                  instanceOf: 'Constructor',   
 ], Type.Boolean())              ) => boolean                   parameters: [{               
                                                                  type: 'string'             
                                                                }, {                         
                                                                  type: 'number'             
                                                                }],                          
                                                                return: {                    
                                                                  type: 'boolean'            
                                                                }                            
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Function([       type T = (                   const T = {                    
|   Type.String(),                 arg0: string,                 type : 'object',             
   Type.Number()                  arg1: number                  instanceOf: 'Function',      
 ], Type.Boolean())              ) => boolean                   parameters: [{               
                                                                  type: 'string'             
                                                                }, {                         
                                                                  type: 'number'             
                                                                }],                          
                                                                return: {                    
                                                                  type: 'boolean'            
                                                                }                            
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Promise(         type T = Promise<string>     const T = {                    
   Type.String()                                                type: 'object',              
 )                                                              instanceOf: 'Promise',       
                                                                item: {                      
                                                                  type: 'string'             
                                                                }                            
                                                              }                              
                                                                                             
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Uint8Array()     type T = Uint8Array          const T = {                    
                                                                type: 'object',              
                                                                instanceOf: 'Uint8Array'     
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Date()           type T = Date                const T = {                    
                                                                type: 'object',              
                                                                instanceOf: 'Date'           
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Undefined()      type T = undefined           const T = {                    
                                                                type: 'null',                
                                                                typeOf: 'Undefined'          
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.RegEx(/foo/)     type T = string              const T = {                    
                                                                 type: 'string',             
                                                                 pattern: 'foo'              
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Symbol()         type T = symbol              const T = {                    
                                                                type: 'null',                
                                                                typeOf: 'Symbol'             
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.BigInt()         type T = bigint              const T = {                    
                                                                type: 'null',                
                                                                typeOf: 'BigInt'             
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Void()           type T = void                const T = {                    
                                                                type: 'null'                 
                                                                typeOf: 'Void'               
                                                              }                              
                                                                                             
└────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘

Modifiers

TypeBox provides modifiers that allow schema properties to be statically inferred as readonly or optional. The following table shows the supported modifiers and how they map between TypeScript and JSON Schema.

┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
 TypeBox                         TypeScript                   JSON Schema                    
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Object({         type T = {                   const T = {                    
   name: Type.Optional(            name?: string                type: 'object',              
     Type.String()               }                              properties: {                
   )                                                              name: {                    
 })  	                                                             type: 'string'           
                                                                  }                          
                                                                }                            
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Object({         type T = {                   const T = {                    
   name: Type.Readonly(            readonly name: string        type: 'object',              
     Type.String()               }                              properties: {                
   )                                                              name: {                    
 })  	                                                             type: 'string'           
                                                                  }                          
                                                                },                           
                                                                required: ['name']           
                                                              }                              
                                                                                             
├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 const T = Type.Object({         type T = {                   const T = {                    
   name: Type.ReadonlyOptional(    readonly name?: string       type: 'object',              
     Type.String()               }                              properties: {                
   )                                                              name: {                    
 })  	                                                             type: 'string'           
                                                                  }                          
                                                                }                            
                                                              }                              
                                                                                             
└────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘

Options

You can pass JSON Schema options on the last argument of any type. Option hints specific to each type are provided for convenience.

// String must be an email
const T = Type.String({                              // const T = { 
  format: 'email'                                    //   type: 'string',
})                                                   //   format: 'email' 
                                                     // }

// Mumber must be a multiple of 2
const T = Type.Number({                              // const T = { 
  multipleOf: 2                                      //  type: 'number', 
})                                                   //  multipleOf: 2 
                                                     // }

// Array must have at least 5 integer values
const T = Type.Array(Type.Integer(), {               // const T = { 
  minItems: 5                                        //   type: 'array',
})                                                   //   minItems: 5,        
                                                     //   items: { 
                                                     //     type: 'integer'
                                                     //   }
                                                     // }

Generic Types

Generic types can be created with generic functions constrained to type TSchema. The following creates a generic Vector<T> type.

import { Type, Static, TSchema } from '@sinclair/typebox'

const Vector = <T extends TSchema>(t: T) => Type.Object({ x: t, y: t, z: t })

const NumberVector = Vector(Type.Number())           // const NumberVector = {
                                                     //   type: 'object',
                                                     //   required: ['x', 'y', 'z'],
                                                     //   properties: {
                                                     //     x: { type: 'number' },
                                                     //     y: { type: 'number' },
                                                     //     z: { type: 'number' }
                                                     //   }
                                                     // }

type NumberVector = Static<typeof NumberVector>      // type NumberVector = {
                                                     //   x: number,
                                                     //   y: number,
                                                     //   z: number
                                                     // }

const BooleanVector = Vector(Type.Boolean())         // const BooleanVector = {
                                                     //   type: 'object',
                                                     //   required: ['x', 'y', 'z'],
                                                     //   properties: {
                                                     //     x: { type: 'boolean' },
                                                     //     y: { type: 'boolean' },
                                                     //     z: { type: 'boolean' }
                                                     //   }
                                                     // }

type BooleanVector = Static<typeof BooleanVector>    // type BooleanVector = {
                                                     //   x: boolean,
                                                     //   y: boolean,
                                                     //   z: boolean
                                                     // }

The following creates a generic Nullable<T> type.

const Nullable = <T extends TSchema>(schema: T) => Type.Union([schema, Type.Null()])

const T = Nullable(Type.String())                   // const T = {
                                                    //   anyOf: [
                                                    //     { type: 'string' },
                                                    //     { type: 'null' }
                                                    //   ]
                                                    // }

type T = Static<typeof T>                           // type T = string | null

Reference Types

Reference types are supported with Type.Ref. The target type must specify a valid $id.

const T = Type.String({ $id: 'T' })                  // const T = {
                                                     //    $id: 'T',
                                                     //    type: 'string'
                                                     // }
                                             
const R = Type.Ref(T)                                // const R = {
                                                     //    $ref: 'T'
                                                     // }

Recursive Types

Recursive types are supported with Type.Recursive

const Node = Type.Recursive(Node => Type.Object({    // const Node = {
  id: Type.String(),                                 //   $id: 'Node',
  nodes: Type.Array(Node)                            //   type: 'object',
}), { $id: 'Node' })                                 //   properties: {
                                                     //     id: {
                                                     //       type: 'string'
                                                     //     },
                                                     //     nodes: {
                                                     //       type: 'array',
                                                     //       items: {
                                                     //         $ref: 'Node'
                                                     //       }
                                                     //     }
                                                     //   },
                                                     //   required: [
                                                     //     'id',
                                                     //     'nodes'
                                                     //   ]
                                                     // }

type Node = Static<typeof Node>                      // type Node = {
                                                     //   id: string
                                                     //   nodes: Node[]
                                                     // }

function test(node: Node) {
  const id = node.nodes[0].nodes[0].id               // id is string
}

Conditional Types

Conditional types are supported with Type.Extends, Type.Exclude and Type.Extract

// TypeScript

type T0 = string extends number ? true : false       // type T0 = false

type T1 = Extract<string | number, number>           // type T1 = number

type T2 = Exclude<string | number, number>           // type T2 = string

// TypeBox

const T0 = Type.Extends(Type.String(), Type.Number(), Type.Literal(true), Type.Literal(false))

const T1 = Type.Extract(Type.Union([Type.String(), Type.Number()]), Type.Number())

const T2 = Type.Exclude(Type.Union([Type.String(), Type.Number()]), Type.Number())


type T0 = Static<typeof T0>                        // type T0 = false

type T1 = Static<typeof T1>                        // type T1 = number

type T2 = Static<typeof T2>                        // type T2 = string 

Template Literal Types

TypeBox supports Template Literal types using Type.TemplateLiteral. These types can be created using a simple template DSL syntax, however more complex template literals can be created by passing an array of literal and union types. The examples below show the template DSL syntax.

// TypeScript

type P = `/post/${string}/user/${number}`            // type P = `/post/${string}/user/${number}`

type T = `option${'A'|'B'}`                          // type T = 'optionA' | 'optionB'

type R = Record<T, string>                           // type R = {
                                                     //   optionA: string
                                                     //   optionB: string
                                                     // }

// TypeBox

const P = Type.TemplateLiteral('/post/${string}/user/${number}')

                                                     // const P = {
                                                     //   type: 'string',
                                                     //   pattern: '^/post/(.*)/user/(0|[1-9][0-9]*)$'
                                                     // }

const T = Type.TemplateLiteral('option${A|B}')       // const T = {
                                                     //   pattern: '^option(A|B)$',
                                                     //   type: 'string'
                                                     // }

const R = Type.Record(T, Type.String())              // const R = {
                                                     //   type: 'object',
                                                     //   required: ['optionA', 'optionB'],
                                                     //   properties: {
                                                     //     optionA: {
                                                     //       type: 'string'
                                                     //     },
                                                     //     optionB: {
                                                     //       type: 'string'
                                                     //     }
                                                     //   }
                                                     // }

Indexed Access Types

TypeBox supports Indexed Access types using Type.Index. This feature provides a consistent way to access property types without having to extract them from the underlying schema representation. Indexed accessors are supported for object and tuples, as well as nested union and intersect types.

const T = Type.Object({                              // const T = {
  x: Type.Number(),                                  //   type: 'object',
  y: Type.String(),                                  //   required: ['x', 'y', 'z'],
  z: Type.Boolean()                                  //   properties: {
})                                                   //     x: { type: 'number' },
                                                     //     y: { type: 'string' },
                                                     //     z: { type: 'string' },
                                                     //   }
                                                     // }

const A = Type.Index(T, ['x'])                       // const A = { type: 'number' }

const B = Type.Index(T, ['x', 'y'])                  // const B = { 
                                                     //   anyOf: [
                                                     //     { type: 'number' },  
                                                     //     { type: 'string' }
                                                     //   ]
                                                     // }

const C = Type.Index(T, Type.KeyOf(T))               // const C = { 
                                                     //   anyOf: [
                                                     //     { type: 'number' },  
                                                     //     { type: 'string' },
                                                     //     { type: 'boolean' }
                                                     //   ]
                                                     // }

Rest Types

Rest parameters are supported with Type.Rest. This function is used to extract interior type elements from tuples which enables them to compose with the JavaScript spread operator .... This type can be used for tuple concatination as well as for variadic functions.

// TypeScript

type T = [number, number]                            // type T = [number, number]

type C = [...T, number]                              // type C = [number, number, number]

type F = (...param: C) => void                       // type F = (
                                                     //   param0: number,
                                                     //   param1: number,
                                                     //   param2: number,
                                                     // ) => void

// TypeBox

const T = Type.Tuple([                               // const T: TTuple<[
  Type.Number(),                                     //   TNumber,
  Type.Number()                                      //   TNumber,
])                                                   // ]>

const C = Type.Tuple([                               // const C: TTuple<[
  ...Type.Rest(T),                                   //   TNumber,
  Type.Number()                                      //   TNumber,
])                                                   //   TNumber
                                                     // ]>

const F = Type.Function(Type.Rest(C), Type.Void())   // const F: TFunction<[
                                                     //   TNumber,
                                                     //   TNumber,
                                                     //   TNumber
                                                     // ], TVoid>

Unsafe Types

Use Type.Unsafe to create custom schematics with user defined inference rules.

const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
                                                     //   type: 'number'
                                                     // }

type T = Static<typeof T>                            // type T = string

The Type.Unsafe type can be useful to express specific OpenAPI schema representations.

import { Type, Static, TSchema } from '@sinclair/typebox'

// Nullable<T>

function Nullable<T extends TSchema>(schema: T) {
  return Type.Unsafe<Static<T> | null>({ ...schema, nullable: true })
}

const T = Nullable(Type.String())                    // const T = {
                                                     //   type: 'string',
                                                     //   nullable: true
                                                     // }

type T = Static<typeof T>                            // type T = string | null

// StringEnum<string[]>

function StringEnum<T extends string[]>(values: [...T]) {
  return Type.Unsafe<T[number]>({ type: 'string', enum: values })
}

const T = StringEnum(['A', 'B', 'C'])                // const T = {
                                                     //   enum: ['A', 'B', 'C']
                                                     // }

type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'

Type Guards

TypeBox provides a TypeGuard module that can be used for reflection and asserting values as types.

import { Type, TypeGuard } from '@sinclair/typebox'

const T = Type.String()

if(TypeGuard.TString(T)) {
    
  // T is TString
}

Strict

TypeBox schemas contain the Kind and Modifier symbol properties. These properties are used for type composition and reflection. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a Type.Strict function that will omit these properties if necessary.

const T = Type.Object({                              // const T = {
  name: Type.Optional(Type.String())                 //   [Kind]: 'Object',
})                                                   //   type: 'object',
                                                     //   properties: {
                                                     //     name: {
                                                     //       [Kind]: 'String',
                                                     //       type: 'string',
                                                     //       [Modifier]: 'Optional'
                                                     //     }
                                                     //   }
                                                     // }

const U = Type.Strict(T)                             // const U = {
                                                     //   type: 'object', 
                                                     //   properties: { 
                                                     //     name: { 
                                                     //       type: 'string' 
                                                     //     } 
                                                     //   } 
                                                     // }

Values

TypeBox provides an optional utility module that can be used to perform common operations on JavaScript values. This module includes functionality to create, check and cast values from types as well as check equality, clone, diff and patch JavaScript values. This module is provided via optional import.

import { Value } from '@sinclair/typebox/value'

Create

Use the Create function to create a value from a type. TypeBox will use default values if specified.

const T = Type.Object({ x: Type.Number(), y: Type.Number({ default: 42 }) })

const A = Value.Create(T)                            // const A = { x: 0, y: 42 }

Clone

Use the Clone function to deeply clone a value

const A = Value.Clone({ x: 1, y: 2, z: 3 })          // const A = { x: 1, y: 2, z: 3 }

Check

Use the Check function to type check a value

const T = Type.Object({ x: Type.Number() })

const R = Value.Check(T, { x: 1 })                   // const R = true

Convert

Use the Convert function to convert a value into its target type if a reasonable conversion is possible.

const T = Type.Object({ x: Type.Number() })

const R1 = Value.Convert(T, { x: '3.14' })          // const R1 = { x: 3.14 }

const R2 = Value.Convert(T, { x: 'not a number' })  // const R2 = { x: 'not a number' }

Cast

Use the Cast function to cast a value into a type. The cast function will retain as much information as possible from the original value.

const T = Type.Object({ x: Type.Number(), y: Type.Number() }, { additionalProperties: false })

const X = Value.Cast(T, null)                        // const X = { x: 0, y: 0 }

const Y = Value.Cast(T, { x: 1 })                    // const Y = { x: 1, y: 0 }

const Z = Value.Cast(T, { x: 1, y: 2, z: 3 })        // const Z = { x: 1, y: 2 }

Equal

Use the Equal function to deeply check for value equality.

const R = Value.Equal(                               // const R = true
  { x: 1, y: 2, z: 3 },
  { x: 1, y: 2, z: 3 }
)

Hash

Use the Hash function to create a FNV1A-64 non cryptographic hash of a value.

const A = Value.Hash({ x: 1, y: 2, z: 3 })          // const A = 2910466848807138541n

const B = Value.Hash({ x: 1, y: 4, z: 3 })          // const B = 1418369778807423581n

Diff

Use the Diff function to produce a sequence of edits to transform one value into another.

const E = Value.Diff(                               // const E = [
  { x: 1, y: 2, z: 3 },                             //   { type: 'update', path: '/y', value: 4 },
  { y: 4, z: 5, w: 6 }                              //   { type: 'update', path: '/z', value: 5 },
)                                                   //   { type: 'insert', path: '/w', value: 6 },
                                                    //   { type: 'delete', path: '/x' }
                                                    // ]

Patch

Use the Patch function to apply edits

const A = { x: 1, y: 2 }

const B = { x: 3 }

const E = Value.Diff(A, B)                           // const E = [
                                                     //   { type: 'update', path: '/x', value: 3 },
                                                     //   { type: 'delete', path: '/y' }
                                                     // ]

const C = Value.Patch<typeof B>(A, E)                // const C = { x: 3 }

Errors

Use the Errors function enumerate validation errors.

const T = Type.Object({ x: Type.Number(), y: Type.Number() })

const R = [...Value.Errors(T, { x: '42' })]          // const R = [{
                                                     //   schema: { type: 'number' },
                                                     //   path: '/x',
                                                     //   value: '42',
                                                     //   message: 'Expected number'
                                                     // }, {
                                                     //   schema: { type: 'number' },
                                                     //   path: '/y',
                                                     //   value: undefined,
                                                     //   message: 'Expected number'
                                                     // }]

Mutate

Use the Mutate function to perform a deep mutable value assignment while retaining internal references.

const Y = { z: 1 }                                   // const Y = { z: 1 } 

const X = { y: Y }                                   // const X = { y: { z: 1 } }

const A = { x: X }                                   // const A = { x: { y: { z: 1 } } }             


Value.Mutate(A, { x: { y: { z: 2 } } })              // const A' = { x: { y: { z: 2 } } }   

const R0 = A.x.y.z === 2                             // const R0 = 2

const R1 = A.x.y === Y                               // const R1 = true

const R2 = A.x === X                                 // const R2 = true

Pointer

Use ValuePointer to perform mutable updates on existing values using RFC6901 JSON Pointers.

import { ValuePointer } from '@sinclair/typebox/value'

const A = { x: 0, y: 0, z: 0 }

ValuePointer.Set(A, '/x', 1)                         // const A' = { x: 1, y: 0, z: 0 }

ValuePointer.Set(A, '/y', 1)                         // const A' = { x: 1, y: 1, z: 0 }

ValuePointer.Set(A, '/z', 1)                         // const A' = { x: 1, y: 1, z: 1 }

TypeCheck

TypeBox types target JSON Schema draft 6 so are compatible with any validator that supports this specification. TypeBox also provides a built in type checking compiler designed specifically for high performance compilation and value assertion.

The following sections detail using Ajv and TypeBox's compiler infrastructure.

Ajv

The following shows the recommended setup for Ajv.

$ npm install ajv ajv-formats --save
import { Type }   from '@sinclair/typebox'
import addFormats from 'ajv-formats'
import Ajv        from 'ajv'

const ajv = addFormats(new Ajv({}), [
  'date-time', 
  'time', 
  'date', 
  'email',  
  'hostname', 
  'ipv4', 
  'ipv6', 
  'uri', 
  'uri-reference', 
  'uuid',
  'uri-template', 
  'json-pointer', 
  'relative-json-pointer', 
  'regex'
])

const C = ajv.compile(Type.Object({                
  x: Type.Number(),
  y: Type.Number(),
  z: Type.Number()
}))

const R = C({ x: 1, y: 2, z: 3 })                    // const R = true 

TypeCompiler

The TypeBox TypeCompiler is a high performance JIT compiler that transforms TypeBox types into optimized JavaScript validation routines. The compiler is tuned for fast compilation as well as fast value assertion. It is designed to serve as a validation backend that can be integrated into larger applications; but can also be used as a general purpose validator.

The TypeCompiler is provided as an optional import.

import { TypeCompiler } from '@sinclair/typebox/compiler'

Use the Compile(...) function to compile a type.

const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
  x: Type.Number(),                                  //     x: TNumber;
  y: Type.Number(),                                  //     y: TNumber;
  z: Type.Number()                                   //     z: TNumber;
}))                                                  // }>>

const R = C.Check({ x: 1, y: 2, z: 3 })              // const R = true

Use the Errors(...) function to produce diagnostic errors for a value. The Errors(...) function will return an iterator that if enumerated; will perform an exhaustive check across the entire value and yield any error found. For performance, this function should only be called after failed Check(...). Applications may also choose to yield only the first value to avoid exhaustive error generation.

const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
  x: Type.Number(),                                  //     x: TNumber;
  y: Type.Number(),                                  //     y: TNumber;
  z: Type.Number()                                   //     z: TNumber;
}))                                                  // }>>

const value = { }

const errors = [...C.Errors(value)]                  // const errors = [{
                                                     //   schema: { type: 'number' },
                                                     //   path: '/x',
                                                     //   value: undefined,
                                                     //   message: 'Expected number'
                                                     // }, {
                                                     //   schema: { type: 'number' },
                                                     //   path: '/y',
                                                     //   value: undefined,
                                                     //   message: 'Expected number'
                                                     // }, {
                                                     //   schema: { type: 'number' },
                                                     //   path: '/z',
                                                     //   value: undefined,
                                                     //   message: 'Expected number'
                                                     // }]

Compiled routines can be inspected with the .Code() function.

const C = TypeCompiler.Compile(Type.String())        // const C: TypeCheck<TString>

console.log(C.Code())                                // return function check(value) {
                                                     //   return (
                                                     //     (typeof value === 'string')
                                                     //   )
                                                     // }

TypeSystem

The TypeBox TypeSystem module provides functionality to define types above and beyond the Standard and Extended type sets as well as control various assertion polices. Configurations made to the TypeSystem module are observed by both TypeCompiler and Value modules.

The TypeSystem module is provided as an optional import.

import { TypeSystem } from '@sinclair/typebox/system'

Types

Use the Type(...) function to create a custom type. This function will return a type factory function that can be used to construct the type. The following creates a Point type.

type PointOptions = { }                              // The Type Options

type PointType = { x: number, y: number }            // The Static<T> Type

const Point = TypeSystem.Type<PointType, PointOptions>('Point', (options, value) => {
  return (
    typeof value === 'object' && value !== null &&
    typeof value.x === 'number' && 
    typeof value.y === 'number'
  )
})

const T = Point()

type T = Static<typeof T>                             // type T = { x: number, y: number }

const R = Value.Check(T, { x: 1, y: 2 })              // const R = true

Formats

Use the Format(...) function to create a custom string format. The following creates a format that checks for lowercase strings.

TypeSystem.Format('lowercase', value => value === value.toLowerCase()) // format should be lowercase

const T = Type.String({ format: 'lowercase' })       

const A = Value.Check(T, 'Hello')                    // const A = false

const B = Value.Check(T, 'hello')                    // const B = true

Policies

TypeBox validates using standard JSON Schema assertion policies by default. It is possible to override some of these policies to have TypeBox assert inline with TypeScript static assertion rules. The following policy overrides are available.

// Disallow undefined values for optional properties (default is false)
//
// const A: { x?: number } = { x: undefined } - disallowed when enabled

TypeSystem.ExactOptionalPropertyTypes = true

// Allow arrays to validate as object types (default is false)
//
// const A: {} = [] - allowed in TS

TypeSystem.AllowArrayObjects = true                  

// Allow numeric values to be NaN or + or - Infinity (default is false)
//
// const A: number = NaN - allowed in TS

TypeSystem.AllowNaN = true                      

Benchmark

This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running npm run benchmark. The results below show for Ajv version 8.12.0 running on Node 20.0.0.

For additional comparative benchmarks, please refer to typescript-runtime-type-benchmarks.

Compile

This benchmark measures compilation performance for varying types. You can review this benchmark here.

┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
          (index)            Iterations      Ajv       TypeCompiler  Performance  
├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
 Literal_String                 1000     '    243 ms'  '      8 ms'  '   30.38 x' 
 Literal_Number                 1000     '    195 ms'  '      5 ms'  '   39.00 x' 
 Literal_Boolean                1000     '    162 ms'  '      4 ms'  '   40.50 x' 
 Primitive_Number               1000     '    168 ms'  '      6 ms'  '   28.00 x' 
 Primitive_String               1000     '    164 ms'  '      5 ms'  '   32.80 x' 
 Primitive_String_Pattern       1000     '    214 ms'  '      9 ms'  '   23.78 x' 
 Primitive_Boolean              1000     '    132 ms'  '      4 ms'  '   33.00 x' 
 Primitive_Null                 1000     '    148 ms'  '      4 ms'  '   37.00 x' 
 Object_Unconstrained           1000     '   1158 ms'  '     30 ms'  '   38.60 x' 
 Object_Constrained             1000     '   1263 ms'  '     25 ms'  '   50.52 x' 
 Object_Vector3                 1000     '    384 ms'  '      7 ms'  '   54.86 x' 
 Object_Box3D                   1000     '   1932 ms'  '     27 ms'  '   71.56 x' 
 Tuple_Primitive                1000     '    478 ms'  '     14 ms'  '   34.14 x' 
 Tuple_Object                   1000     '   1232 ms'  '     14 ms'  '   88.00 x' 
 Composite_Intersect            1000     '    671 ms'  '     17 ms'  '   39.47 x' 
 Composite_Union                1000     '    537 ms'  '     18 ms'  '   29.83 x' 
 Math_Vector4                   1000     '    816 ms'  '     14 ms'  '   58.29 x' 
 Math_Matrix4                   1000     '    417 ms'  '      6 ms'  '   69.50 x' 
 Array_Primitive_Number         1000     '    378 ms'  '      5 ms'  '   75.60 x' 
 Array_Primitive_String         1000     '    353 ms'  '      6 ms'  '   58.83 x' 
 Array_Primitive_Boolean        1000     '    279 ms'  '      5 ms'  '   55.80 x' 
 Array_Object_Unconstrained     1000     '   1794 ms'  '     20 ms'  '   89.70 x' 
 Array_Object_Constrained       1000     '   1586 ms'  '     19 ms'  '   83.47 x' 
 Array_Tuple_Primitive          1000     '    791 ms'  '     13 ms'  '   60.85 x' 
 Array_Tuple_Object             1000     '   1638 ms'  '     17 ms'  '   96.35 x' 
 Array_Composite_Intersect      1000     '    796 ms'  '     17 ms'  '   46.82 x' 
 Array_Composite_Union          1000     '    798 ms'  '     15 ms'  '   53.20 x' 
 Array_Math_Vector4             1000     '   1127 ms'  '     14 ms'  '   80.50 x' 
 Array_Math_Matrix4             1000     '    677 ms'  '      9 ms'  '   75.22 x' 
└────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘

Validate

This benchmark measures validation performance for varying types. You can review this benchmark here.

┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
          (index)            Iterations   ValueCheck       Ajv       TypeCompiler  Performance  
├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
 Literal_String               1000000    '     24 ms'  '      5 ms'  '      4 ms'  '    1.25 x' 
 Literal_Number               1000000    '     21 ms'  '     17 ms'  '     10 ms'  '    1.70 x' 
 Literal_Boolean              1000000    '     19 ms'  '     19 ms'  '     10 ms'  '    1.90 x' 
 Primitive_Number             1000000    '     24 ms'  '     18 ms'  '     10 ms'  '    1.80 x' 
 Primitive_String             1000000    '     26 ms'  '     17 ms'  '      9 ms'  '    1.89 x' 
 Primitive_String_Pattern     1000000    '    159 ms'  '     45 ms'  '     36 ms'  '    1.25 x' 
 Primitive_Boolean            1000000    '     22 ms'  '     17 ms'  '     10 ms'  '    1.70 x' 
 Primitive_Null               1000000    '     23 ms'  '     17 ms'  '      9 ms'  '    1.89 x' 
 Object_Unconstrained         1000000    '    914 ms'  '     34 ms'  '     26 ms'  '    1.31 x' 
 Object_Constrained           1000000    '   1095 ms'  '     50 ms'  '     38 ms'  '    1.32 x' 
 Object_Vector3               1000000    '    414 ms'  '     23 ms'  '     14 ms'  '    1.64 x' 
 Object_Box3D                 1000000    '   1933 ms'  '     55 ms'  '     53 ms'  '    1.04 x' 
 Object_Recursive             1000000    '   4995 ms'  '    378 ms'  '    177 ms'  '    2.14 x' 
 Tuple_Primitive              1000000    '    168 ms'  '     24 ms'  '     13 ms'  '    1.85 x' 
 Tuple_Object                 1000000    '    681 ms'  '     31 ms'  '     19 ms'  '    1.63 x' 
 Composite_Intersect          1000000    '    718 ms'  '     25 ms'  '     15 ms'  '    1.67 x' 
 Composite_Union              1000000    '    511 ms'  '     24 ms'  '     14 ms'  '    1.71 x' 
 Math_Vector4                 1000000    '    285 ms'  '     23 ms'  '     12 ms'  '    1.92 x' 
 Math_Matrix4                 1000000    '   1197 ms'  '     39 ms'  '     28 ms'  '    1.39 x' 
 Array_Primitive_Number       1000000    '    294 ms'  '     22 ms'  '     12 ms'  '    1.83 x' 
 Array_Primitive_String       1000000    '    251 ms'  '     22 ms'  '     14 ms'  '    1.57 x' 
 Array_Primitive_Boolean      1000000    '    131 ms'  '     22 ms'  '     14 ms'  '    1.57 x' 
 Array_Object_Unconstrained   1000000    '   5249 ms'  '     69 ms'  '     56 ms'  '    1.23 x' 
 Array_Object_Constrained     1000000    '   5299 ms'  '    127 ms'  '    123 ms'  '    1.03 x' 
 Array_Object_Recursive       1000000    '  19609 ms'  '   1711 ms'  '    608 ms'  '    2.81 x' 
 Array_Tuple_Primitive        1000000    '    734 ms'  '     38 ms'  '     30 ms'  '    1.27 x' 
 Array_Tuple_Object           1000000    '   2843 ms'  '     63 ms'  '     51 ms'  '    1.24 x' 
 Array_Composite_Intersect    1000000    '   2794 ms'  '     43 ms'  '     36 ms'  '    1.19 x' 
 Array_Composite_Union        1000000    '   1892 ms'  '     66 ms'  '     33 ms'  '    2.00 x' 
 Array_Math_Vector4           1000000    '   1177 ms'  '     37 ms'  '     23 ms'  '    1.61 x' 
 Array_Math_Matrix4           1000000    '   5115 ms'  '    110 ms'  '     85 ms'  '    1.29 x' 
└────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘

Compression

The following table lists esbuild compiled and minified sizes for each TypeBox module.

┌──────────────────────┬────────────┬────────────┬─────────────┐
       (index)          Compiled    Minified   Compression 
├──────────────────────┼────────────┼────────────┼─────────────┤
 typebox/compiler      '127.1 kb'  ' 56.7 kb'   '2.24 x'   
 typebox/errors        '110.9 kb'  ' 48.9 kb'   '2.27 x'   
 typebox/system        ' 76.3 kb'  ' 31.2 kb'   '2.44 x'   
 typebox/value         '176.8 kb'  ' 76.5 kb'   '2.31 x'   
 typebox               ' 75.2 kb'  ' 30.8 kb'   '2.44 x'   
└──────────────────────┴────────────┴────────────┴─────────────┘

Contribute

TypeBox is open to community contribution. Please ensure you submit an open issue before submitting your pull request. The TypeBox project preferences open community discussion prior to accepting new features.