@sinclair/typebox
    TypeScript icon, indicating that this package has built-in type declarations

    0.24.10 • Public • Published

    TypeBox

    JSON Schema Type Builder with Static Type Resolution for TypeScript



    npm version GitHub CI

    Install

    Node

    $ npm install @sinclair/typebox --save

    Deno

    import { Static, Type } from 'https://deno.land/x/typebox/src/typebox.ts'

    Example

    import { Static, Type } from '@sinclair/typebox'
    
    const T = Type.String()     // const T = { type: 'string' }
    
    type T = Static<typeof T>   // type T = string

    Overview

    TypeBox is a type builder library 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 checking rules of the TypeScript compiler. TypeBox allows one to compose unified types that can be statically asserted by the TypeScript compiler as well as runtime asserted using standard JSON Schema validation.

    TypeBox can be used as a simple tool to build up complex schemas or integrated into RPC or REST services to help validate JSON data received over the wire. It can be used in both TypeScript and JavaScript environments.

    License MIT

    Contents

    Usage

    The following demonstrates TypeBox's 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.
    //
    //--------------------------------------------------------------------------------------------
    
    function receive(value: T) {                         // ... as a Type
    
      if(JSON.validate(T, value)) {                      // ... as a Schema
            // ok...
      }
    }

    Types

    The following table outlines the TypeBox mappings between TypeScript and JSON schema.

    ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
     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.RegEx(/foo/)     type T = string              const T = {                    
                                                                     type: 'string',             
                                                                     pattern: 'foo'              
                                                                  }                              
                                                                                                 
    ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
     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                    properties: { })                              }                                 x: {                      
                                                                         type: 'number'          
                                                                       },                        
                                                                       y: {                      
                                                                         type: 'number'          
                                                                       }                         
                                                                    },                           
                                                                    required: ['x', 'y']         
                                                                  }                              
                                                                                                 
    ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
     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                    type: 'object',              
         x: Type.Number()            } & {                          properties: {   }),                             y: number                      x: {                       
       Type.Object({}                                  type: 'number'           
         y: Type.Number()                                             },                         
       })                                                             y: {                       
     ])                                                                 type: 'number'           
                                                                      }                          
                                                                    },                           
                                                                    required: ['x', 'y']         
                                                                  }                              
                                                                                                 
    ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
     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                   properties: {                
           Type.Number()            | }>                               x: {                       
         ),                                                             type: 'number'           
         y: Type.Optional(                                            },                         
           Type.Number()                                              y: {                       
         )                                                              type: 'number'           
       })                                                             }                          
     )                                                              },                           
                                                                    required: ['x', 'y']         
                                                                  }                              
                                                                                                 
    ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
     const T = Type.Pick(            type T = Pick<{              const T = {                    
       Type.Object({                   x: number,                   type: 'object',              
         x: Type.Number(),             y: number                    properties: {                
         y: Type.Number(),          | }, 'x'>                          x: {                       
       }), ['x']                                                        type: 'number'           
     )                                                                }                          
                                                                    },                           
                                                                    required: ['x']              
                                                                  }                              
                                                                                                 
    ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
     const T = Type.Omit(            type T = Omit<{              const T = {                    
       Type.Object({                   x: number,                   type: 'object',              
         x: Type.Number(),             y: number                    properties: {                
         y: Type.Number(),          | }, 'x'>                          y: {                       
       }), ['x']                                                        type: 'number'           
     )                                                                }                          
                                                                    },                           
                                                                    required: ['y']              
                                                                  }                              
                                                                                                 
    └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘

    Modifiers

    TypeBox provides modifiers that can be applied to an objects properties. This allows for optional and readonly to be applied to that property. The following table illustates 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 additional JSON schema options on the last argument of any given type. The following are some examples.

    // string must be an email
    const T = Type.String({ format: 'email' })
    
    // number must be a multiple of 2
    const T = Type.Number({ multipleOf: 2 })
    
    // array must have at least 5 integer values
    const T = Type.Array(Type.Integer(), { minItems: 5 })

    Extended Types

    In addition to JSON schema types, TypeBox provides several extended types that allow for function and constructor types to be composed. These additional types are not valid JSON Schema and will not validate using typical JSON Schema validation. However, these types can be used to frame JSON schema and describe callable interfaces that may receive JSON validated data. These types are as follows.

    ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
     TypeBox                         TypeScript                   Extended Schema                
                                                                                                 
    ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
     const T = Type.Constructor([    type T = new (               const T = {                    
       Type.String(),                 arg0: string,                 type: 'constructor'          
       Type.Number()                  arg1: number                  arguments: [{                
     ], Type.Boolean())              ) => boolean                     type: 'string'             
                                                                    }, {                         
                                                                      type: 'number'             
                                                                    }],                          
                                                                    returns: {                   
                                                                      type: 'boolean'            
                                                                    }                            
                                                                  }                              
                                                                                                 
    ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
     const T = Type.Function([       type T = (                   const T = {                    
    |   Type.String(),                 arg0: string,                 type : 'function',           
       Type.Number()                  arg1: number                  arguments: [{                
     ], Type.Boolean())              ) => boolean                     type: 'string'             
                                                                    }, {                         
                                                                      type: 'number'             
                                                                    }],                          
                                                                    returns: {                   
                                                                      type: 'boolean'            
                                                                    }                            
                                                                  }                              
                                                                                                 
    ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
     const T = Type.Uint8Array()     type T = Uint8Array          const T = {                    
                                                                    type: 'object',              
                                                                    specialized: 'Uint8Array'    
                                                                  }                              
                                                                                                 
    ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
     const T = Type.Promise(         type T = Promise<string>     const T = {                    
       Type.String()                                                type: 'promise',             
     )                                                              item: {                      
                                                                      type: 'string'             
                                                                    }                            
                                                                  }                              
                                                                                                 
    ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
     const T = Type.Undefined()      type T = undefined           const T = {                    
                                                                    type: 'object',              
                                                                    specialized: 'Undefined'     
                                                                  }                              
                                                                                                 
    ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
     const T = Type.Void()           type T = void                const T = {                    
                                                                    type: 'null'                 
                                                                  }                              
                                                                                                 
    └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘

    Reference Types

    Types can be referenced with Type.Ref(...). To reference a type, the target type must specify an $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 can be created with the Type.Recursive(...) function.

    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: ...
                                                         // }
    
    function visit(node: Node) {
      for(const inner of node.nodes) {
        visit(inner)
      }
    }

    Generic Types

    Generic types can be created using functions. The following creates a generic Nullable<T> type.

    import { Type, Static, TSchema } from '@sinclair/typebox'
    
    const Nullable = <T extends TSchema>(type: T) => Type.Union([type, Type.Null()])
    
    const T = Nullable(Type.String())                    // const T = {
                                                         //   anyOf: [{
                                                         //     type: 'string'
                                                         //   }, {
                                                         //     type: 'null'
                                                         //   }]
                                                         // }
    
    type T = Static<typeof T>                            // type T = string | null
    
    const U = Nullable(Type.Number())                    // const U = {
                                                         //   anyOf: [{
                                                         //     type: 'number'
                                                         //   }, {
                                                         //     type: 'null'
                                                         //   }]
                                                         // }
    
    type U = Static<typeof U>                            // type U = number | null

    Unsafe Types

    In some scenarios, you may need specific schemas not provided by TypeBox. In these cases, it's common to want to define a custom schema with custom static inference rules. The Type.Unsafe(...) function provides this functionality. This function enables one to specify both schema representation and a static type to infer. Consider the following which defines a number schema but infers as string.

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

    The Type.Unsafe(...) function can be combined with function generics to create user defined schemas for validators that need specific schema representations. An example of this might be the OpenAPI nullable and string-enum schema representations which are not provided by TypeBox. The following demonstrates creating these schemas using the Type.Unsafe(...) function.

    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
    
    //--------------------------------------------------------------------------------------------
    //
    // StringUnion<[...]>
    //
    //--------------------------------------------------------------------------------------------
    
    function StringEnum<T extends string[]>(values: [...T]) {
      return Type.Unsafe<T[number]>({ enum: values })
    }
    
    const T = StringEnum(['A', 'B', 'C'])                // const T = {
                                                         //   enum: ['A', 'B', 'C']
                                                         // }
    
    type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'

    Values

    TypeBox can create values from types. It creates reasonable defaults for each value which can overrided by specifying a default value.

    import { Value } from '@sinclair/typebox/value'
    import { Type } from '@sinclair/typebox'
    
    const T = Type.Object({
      x: Type.Number({ default: 1 }),
      y: Type.Number(),
    })
    
    const V = Value.Create(T)                            // const V = {
                                                         //   x: 1,
                                                         //   y: 0,
                                                         // }

    TypeBox also allows values to be upgraded to match the schematics of a given type. The Value.Cast(...) function can be used to upgrade a value into a target type while retaining as much information of the original value as possible. Casts are immutable operations.

    import { Value } from '@sinclair/typebox/value'
    import { Type } from '@sinclair/typebox'
    
    const T = Type.Object({
      x: Type.Number(),
      y: Type.Number()
    })
    
    const A = Value.Cast(T, null)                          // const A = { x: 0, y: 0 }
    
    const B = Value.Cast(T, { x: 1 })                      // const B = { x: 1, y: 0 }
    
    const C = Value.Cast(T, { x: 1, y: 2, z: 3 })          // const C = { x: 1, y: 2 }

    Guards

    If reflecting on TypeBox types, it can be helpful to test if a value matches a TypeBox schematic. This can be achieved using the TypeGuard namespace. The TypeGuard namespace offers exhaustive checks for each known TypeBox type.

    import { TypeGuard } from '@sinclair/typebox/guard'
    import { Type }  from '@sinclair/typebox'
    
    const T: any = {}                                    // T is any
    
    const { type } = T                                   // unsafe: type is any
    
    if(TypeGuard.TString(T)) {
        
      const { type } = T                                 // safe: type is 'string'
    }

    Strict

    TypeBox schemas contain the Kind and Modifier symbol properties. These properties are provided to enable runtime type reflection on schemas, as well as helping TypeBox internally compose types. 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' 
                                                         //     } 
                                                         //   } 
                                                         // }

    Validation

    TypeBox schemas target JSON Schema draft 6 so any validator capable of draft 6 should be fine. A good library to use for validation in JavaScript environments is AJV. The following example shows setting up AJV 7 to work with TypeBox.

    $ npm install ajv ajv-formats --save
    //--------------------------------------------------------------------------------------------
    //
    // Import TypeBox and AJV
    //
    //--------------------------------------------------------------------------------------------
    
    import { Type }   from '@sinclair/typebox'
    import addFormats from 'ajv-formats'
    import Ajv        from 'ajv'
    
    //--------------------------------------------------------------------------------------------
    //
    // Setup AJV validator with the following options and formats
    //
    //--------------------------------------------------------------------------------------------
    
    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'
    ])
    
    //--------------------------------------------------------------------------------------------
    //
    // Create a TypeBox type
    //
    //--------------------------------------------------------------------------------------------
    
    const T = Type.Object({
      x: Type.Number(),
      y: Type.Number(),
      z: Type.Number(),
    }, { additionalProperties: false })
    
    //--------------------------------------------------------------------------------------------
    //
    // Validate Data
    //
    //--------------------------------------------------------------------------------------------
    
    const OK = ajv.validate(T, { 
      x: 1,
      y: 2,
      z: 3
    }) // -> true

    Please refer to the official AJV documentation for additional information on using AJV.

    Compiler

    TypeBox includes a specialized TypeCompiler that can be used as a runtime type checker in lieu of a JSON Schema validator. This compiler is optimized for high throughput Web Socket messaging and can perform better than AJV for some structural checks. Please note that this compiler is not fully JSON Schema compliant and is limited to known TypeBox types only. The TypeCompiler contains a Compile(T) function that returns a TypeCheck<T> object that can be used to test the validity of a value as well as obtain errors.

    import { TypeCompiler } from '@sinclair/typebox/compiler'
    import { Type } from '@sinclair/typebox'
    
    const T = Type.Object({
      x: Type.Number(),
      y: Type.Number(),
      z: Type.Number()
    })
    
    const C = TypeCompiler.Compile(T)
    
    const OK = C.Check({ 
      x: 1, 
      y: 2, 
      z: 3 
    }) // -> true

    Errors can be obtained by calling the Errors(...) function. This function returns an iterator that may contain zero or more errors for the given value. For performance, you should only call Errors(V) if the Check(V) function returns false.

    const C = TypeCompiler.Compile(Type.Object({
      x: Type.Number(),
      y: Type.Number(),
      z: Type.Number()
    }))
    
    const V = { } // invalid
    
    if(!C.Check(V)) {
      for(const error of C.Errors(V)) {
        console.log(error)
      }
    }

    The TypeCompiler generates JavaScript validation routines types that are evaluated at runtime. You can inspect the generated code by calling the Code() function of the TypeCheck<T> object.

    const C = TypeCompiler.Compile(Type.String())
    
    console.log(C.Code())
    //
    // outputs:
    //
    // return function check(value) {
    //   return (
    //     (typeof value === 'string')
    //  )
    // }

    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.

    Install

    npm i @sinclair/typebox

    DownloadsWeekly Downloads

    3,887,431

    Version

    0.24.10

    License

    MIT

    Unpacked Size

    182 kB

    Total Files

    25

    Last publish

    Collaborators

    • sinclair