@sinclair/typebox 0.24.22 → 0.24.25

package/readme.md

@@ -47,30 +47,30 @@ type T = Static<typeof T>   // type T = string
 
 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 enables one to create unified types that can be statically checked by TypeScript and 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 data received over the wire. It offers a type system aligned to the capabilities of TypeScript and can be used equally well in JavaScript environments.
+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.
 
 License MIT
 
 ## Contents
-- [Install](#Install)
-- [Overview](#Overview)
-- [Usage](#Usage)
-- [Types](#Types)
-- [Modifiers](#Modifiers)
-- [Options](#Options)
-- [Extended Types](#Extended-Types)
-- [Reference Types](#Reference-Types)
-- [Recursive Types](#Recursive-Types)
-- [Generic Types](#Generic-Types)
-- [Unsafe Types](#Unsafe-Types)
-- [Conditional Types](#Conditional-Types)
-- [Values](#Values)
-- [Guards](#Guards)
-- [Strict](#Strict)
-- [Validation](#Validation)
-- [Compiler](#Compiler)
-- [Benchmark](#Benchmark)
-- [Contribute](#Contribute)
+- [Install](#install)
+- [Overview](#overview)
+- [Usage](#usage)
+- [Types](#types)
+- [Modifiers](#modifiers)
+- [Options](#options)
+- [Extended Types](#extended-types)
+- [Reference Types](#reference-types)
+- [Recursive Types](#recursive-types)
+- [Generic Types](#generic-types)
+- [Unsafe Types](#unsafe-types)
+- [Conditional Types](#conditional-types)
+- [Values](#values)
+- [Guards](#guards)
+- [Strict](#strict)
+- [Validation](#validation)
+- [Compiler](#compiler)
+- [Benchmark](#benchmark)
+- [Contribute](#contribute)
 
 <a name="Example"></a>
 
@@ -147,8 +147,6 @@ function receive(value: T) {                         // ... as a Type
 }
 ```
 
-<a name="Types"></a>
-
 ## Types
 
 The following table outlines the TypeBox mappings between TypeScript and JSON schema.
@@ -342,7 +340,6 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
-<a name="Modifiers"></a>
 
 ## Modifiers
 
@@ -386,8 +383,6 @@ TypeBox provides modifiers that can be applied to an objects properties. This al
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name="Options"></a>
-
 ## Options
 
 You can pass additional JSON schema options on the last argument of any given type. The following are some examples.
@@ -403,8 +398,6 @@ const T = Type.Number({ multipleOf: 2 })
 const T = Type.Array(Type.Integer(), { minItems: 5 })
 ```
 
-<a name="Extended-Types"></a>
-
 ## 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.
@@ -467,8 +460,6 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name="Reference-Types"></a>
-
 ## Reference Types
 
 Use `Type.Ref(...)` to create referenced types. The target type must specify an `$id`.
@@ -484,8 +475,6 @@ const R = Type.Ref(T)                                // const R = {
                                                      // }
 ```
 
-<a name="Recursive-Types"></a>
-
 ## Recursive Types
 
 Use `Type.Recursive(...)` to create recursive types.
@@ -524,8 +513,6 @@ function test(node: Node) {
 }
 ```
 
-<a name="Generic-Types"></a>
-
 ## Generic Types
 
 Use functions to create generic types. The following creates a generic `Nullable<T>` type. 
@@ -556,8 +543,6 @@ const U = Nullable(Type.Number())                    // const U = {
 type U = Static<typeof U>                            // type U = number | null
 ```
 
-<a name="Unsafe-Types"></a>
-
 ## Unsafe Types
 
 Use `Type.Unsafe(...)` to create custom schemas with user defined inference rules.
@@ -609,8 +594,6 @@ const T = StringEnum(['A', 'B', 'C'])                // const T = {
 type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 ```
 
-<a name="Conditional-Types"></a>
-
 ## Conditional Types
 
 Use `Conditional.Extends(...)` to create conditional mapped types.
@@ -660,8 +643,6 @@ The following table shows the TypeBox mappings between TypeScript and JSON schem
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name="Values"></a>
-
 ## Values
 
 Use `Value.Create(...)` to generate values from types.
@@ -697,8 +678,6 @@ 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 }
 ```
 
-<a name="Guards"></a>
-
 ## Guards
 
 Use a `TypeGuard` to test if a value meets a TypeBox type specification. Guards can be helpful when reflecting types.
@@ -716,8 +695,6 @@ if(TypeGuard.TString(T)) {
 
 ```
 
-<a name="Strict"></a>
-
 ## 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.
@@ -745,8 +722,6 @@ const U = Type.Strict(T)                             // const U = {
                                                      // }
 ```
 
-<a name="Validation"></a>
-
 ## 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](https://www.npmjs.com/package/ajv). The following example shows setting up Ajv to work with TypeBox.
@@ -812,8 +787,6 @@ const R = ajv.validate(T, { x: 1, y: 2, z: 3 })      // const R = true
 
 Please refer to the official Ajv [documentation](https://ajv.js.org/guide/getting-started.html) for additional information on using Ajv.
 
-<a name="Compiler"></a>
-
 ## Compiler
 
 TypeBox provides an optional high performance runtime type checker that can be used in applications that require extremely fast validation. This type checker is optimized for TypeBox types only whose schematics are known in advance. If defining custom schemas with `Type.Unsafe<T>` please consider Ajv.
@@ -845,16 +818,19 @@ const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObje
 const value = { }
 
 const errors = [...C.Errors(value)]                  // const errors = [{
+                                                     //   type: 14,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/x',
                                                      //   value: undefined,
                                                      //   message: 'Expected number'
                                                      // }, {
+                                                     //   type: 14,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/y',
                                                      //   value: undefined,
                                                      //   message: 'Expected number'
                                                      // }, {
+                                                     //   type: 14,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/z',
                                                      //   value: undefined,
@@ -874,81 +850,85 @@ console.log(C.Code())                                // return function check(va
                                                      // }
 ```
 
+
+
 ## Benchmark
 
-This project maintains benchmarks that measure Ajv and TypeCompiler validate and compile performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. Results show against Ajv version 8.11.0.
+This project maintains a set of benchmarks that measure Ajv 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.11.0. 
 
-### Validate
+For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
 
-This benchmark measures validation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/check.ts).
+### Compile
+
+This benchmark measures compilation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/compile.ts).
 
 ```typescript
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  4000000   │ '     17 ms' │ '     16 ms' │ '    1.06 x' │
-│           String │  4000000   │ '     74 ms' │ '     37 ms' │ '    2.00 x' │
-│          Boolean │  4000000   │ '     68 ms' │ '     36 ms' │ '    1.89 x' │
-│             Null │  4000000   │ '     68 ms' │ '     36 ms' │ '    1.89 x' │
-│            RegEx │  4000000   │ '    170 ms' │ '    143 ms' │ '    1.19 x' │
-│          ObjectA │  4000000   │ '    122 ms' │ '     84 ms' │ '    1.45 x' │
-│          ObjectB │  4000000   │ '    182 ms' │ '    137 ms' │ '    1.33 x' │
-│            Tuple │  4000000   │ '     82 ms' │ '     48 ms' │ '    1.71 x' │
-│            Union │  4000000   │ '     84 ms' │ '     52 ms' │ '    1.62 x' │
-│        Recursive │  4000000   │ '   1526 ms' │ '    631 ms' │ '    2.42 x' │
-│          Vector4 │  4000000   │ '     80 ms' │ '     42 ms' │ '    1.90 x' │
-│          Matrix4 │  4000000   │ '    157 ms' │ '    113 ms' │ '    1.39 x' │
-│   Literal_String │  4000000   │ '     69 ms' │ '     36 ms' │ '    1.92 x' │
-│   Literal_Number │  4000000   │ '     69 ms' │ '     35 ms' │ '    1.97 x' │
-│  Literal_Boolean │  4000000   │ '     68 ms' │ '     35 ms' │ '    1.94 x' │
-│     Array_Number │  4000000   │ '    119 ms' │ '     60 ms' │ '    1.98 x' │
-│     Array_String │  4000000   │ '    119 ms' │ '     76 ms' │ '    1.57 x' │
-│    Array_Boolean │  4000000   │ '    131 ms' │ '     88 ms' │ '    1.49 x' │
-│    Array_ObjectA │  4000000   │ '  10615 ms' │ '   7053 ms' │ '    1.51 x' │
-│    Array_ObjectB │  4000000   │ '  11305 ms' │ '   8128 ms' │ '    1.39 x' │
-│      Array_Tuple │  4000000   │ '    355 ms' │ '    271 ms' │ '    1.31 x' │
-│      Array_Union │  4000000   │ '    910 ms' │ '    340 ms' │ '    2.68 x' │
-│  Array_Recursive │  4000000   │ '  29101 ms' │ '  10837 ms' │ '    2.69 x' │
-│    Array_Vector4 │  4000000   │ '    381 ms' │ '    212 ms' │ '    1.80 x' │
-│    Array_Matrix4 │  4000000   │ '   1534 ms' │ '   1344 ms' │ '    1.14 x' │
+│           Number │    2000    │ '    382 ms' │ '      8 ms' │ '   47.75 x' │
+│           String │    2000    │ '    305 ms' │ '      7 ms' │ '   43.57 x' │
+│          Boolean │    2000    │ '    305 ms' │ '      5 ms' │ '   61.00 x' │
+│             Null │    2000    │ '    253 ms' │ '      5 ms' │ '   50.60 x' │
+│            RegEx │    2000    │ '    475 ms' │ '     10 ms' │ '   47.50 x' │
+│          ObjectA │    2000    │ '   2812 ms' │ '     44 ms' │ '   63.91 x' │
+│          ObjectB │    2000    │ '   3045 ms' │ '     34 ms' │ '   89.56 x' │
+│            Tuple │    2000    │ '   1324 ms' │ '     19 ms' │ '   69.68 x' │
+│            Union │    2000    │ '   1347 ms' │ '     26 ms' │ '   51.81 x' │
+│          Vector4 │    2000    │ '   1635 ms' │ '     18 ms' │ '   90.83 x' │
+│          Matrix4 │    2000    │ '    928 ms' │ '     10 ms' │ '   92.80 x' │
+│   Literal_String │    2000    │ '    349 ms' │ '      5 ms' │ '   69.80 x' │
+│   Literal_Number │    2000    │ '    379 ms' │ '      5 ms' │ '   75.80 x' │
+│  Literal_Boolean │    2000    │ '    376 ms' │ '      6 ms' │ '   62.67 x' │
+│     Array_Number │    2000    │ '    733 ms' │ '     10 ms' │ '   73.30 x' │
+│     Array_String │    2000    │ '    766 ms' │ '      8 ms' │ '   95.75 x' │
+│    Array_Boolean │    2000    │ '    860 ms' │ '     11 ms' │ '   78.18 x' │
+│    Array_ObjectA │    2000    │ '   3668 ms' │ '     42 ms' │ '   87.33 x' │
+│    Array_ObjectB │    2000    │ '   3809 ms' │ '     41 ms' │ '   92.90 x' │
+│      Array_Tuple │    2000    │ '   2219 ms' │ '     17 ms' │ '  130.53 x' │
+│      Array_Union │    2000    │ '   1709 ms' │ '     26 ms' │ '   65.73 x' │
+│    Array_Vector4 │    2000    │ '   2301 ms' │ '     18 ms' │ '  127.83 x' │
+│    Array_Matrix4 │    2000    │ '   1594 ms' │ '     12 ms' │ '  132.83 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
-### Compile
+### Validate
 
-This benchmark measures compilation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/compile.ts).
+This benchmark measures validation performance for varying types. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/check.ts).
 
 ```typescript
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    384 ms' │ '      7 ms' │ '   54.86 x' │
-│           String │    2000    │ '    311 ms' │ '      6 ms' │ '   51.83 x' │
-│          Boolean │    2000    │ '    304 ms' │ '      5 ms' │ '   60.80 x' │
-│             Null │    2000    │ '    252 ms' │ '      5 ms' │ '   50.40 x' │
-│            RegEx │    2000    │ '    480 ms' │ '      7 ms' │ '   68.57 x' │
-│          ObjectA │    2000    │ '   2786 ms' │ '     27 ms' │ '  103.19 x' │
-│          ObjectB │    2000    │ '   2946 ms' │ '     22 ms' │ '  133.91 x' │
-│            Tuple │    2000    │ '   1277 ms' │ '     16 ms' │ '   79.81 x' │
-│            Union │    2000    │ '   1288 ms' │ '     16 ms' │ '   80.50 x' │
-│          Vector4 │    2000    │ '   1628 ms' │ '     12 ms' │ '  135.67 x' │
-│          Matrix4 │    2000    │ '    912 ms' │ '      7 ms' │ '  130.29 x' │
-│   Literal_String │    2000    │ '    344 ms' │ '      5 ms' │ '   68.80 x' │
-│   Literal_Number │    2000    │ '    432 ms' │ '      5 ms' │ '   86.40 x' │
-│  Literal_Boolean │    2000    │ '    407 ms' │ '      4 ms' │ '  101.75 x' │
-│     Array_Number │    2000    │ '    788 ms' │ '      9 ms' │ '   87.56 x' │
-│     Array_String │    2000    │ '    823 ms' │ '      7 ms' │ '  117.57 x' │
-│    Array_Boolean │    2000    │ '    816 ms' │ '      5 ms' │ '  163.20 x' │
-│    Array_ObjectA │    2000    │ '   4270 ms' │ '     24 ms' │ '  177.92 x' │
-│    Array_ObjectB │    2000    │ '   4008 ms' │ '     28 ms' │ '  143.14 x' │
-│      Array_Tuple │    2000    │ '   2243 ms' │ '     13 ms' │ '  172.54 x' │
-│      Array_Union │    2000    │ '   1734 ms' │ '     16 ms' │ '  108.38 x' │
-│    Array_Vector4 │    2000    │ '   2348 ms' │ '     14 ms' │ '  167.71 x' │
-│    Array_Matrix4 │    2000    │ '   1608 ms' │ '     11 ms' │ '  146.18 x' │
+│           Number │  4000000   │ '     18 ms' │ '     16 ms' │ '    1.13 x' │
+│           String │  4000000   │ '     74 ms' │ '     43 ms' │ '    1.72 x' │
+│          Boolean │  4000000   │ '     71 ms' │ '     37 ms' │ '    1.92 x' │
+│             Null │  4000000   │ '     70 ms' │ '     37 ms' │ '    1.89 x' │
+│            RegEx │  4000000   │ '    175 ms' │ '    153 ms' │ '    1.14 x' │
+│          ObjectA │  4000000   │ '    124 ms' │ '     87 ms' │ '    1.43 x' │
+│          ObjectB │  4000000   │ '    215 ms' │ '    143 ms' │ '    1.50 x' │
+│            Tuple │  4000000   │ '    101 ms' │ '     51 ms' │ '    1.98 x' │
+│            Union │  4000000   │ '    108 ms' │ '     51 ms' │ '    2.12 x' │
+│        Recursive │  4000000   │ '   1647 ms' │ '    626 ms' │ '    2.63 x' │
+│          Vector4 │  4000000   │ '     83 ms' │ '     41 ms' │ '    2.02 x' │
+│          Matrix4 │  4000000   │ '    154 ms' │ '    105 ms' │ '    1.47 x' │
+│   Literal_String │  4000000   │ '    101 ms' │ '     37 ms' │ '    2.73 x' │
+│   Literal_Number │  4000000   │ '     69 ms' │ '     35 ms' │ '    1.97 x' │
+│  Literal_Boolean │  4000000   │ '     71 ms' │ '     35 ms' │ '    2.03 x' │
+│     Array_Number │  4000000   │ '    117 ms' │ '     61 ms' │ '    1.92 x' │
+│     Array_String │  4000000   │ '    116 ms' │ '     73 ms' │ '    1.59 x' │
+│    Array_Boolean │  4000000   │ '    129 ms' │ '     89 ms' │ '    1.45 x' │
+│    Array_ObjectA │  4000000   │ '  10582 ms' │ '   6854 ms' │ '    1.54 x' │
+│    Array_ObjectB │  4000000   │ '  11539 ms' │ '   8224 ms' │ '    1.40 x' │
+│      Array_Tuple │  4000000   │ '    362 ms' │ '    282 ms' │ '    1.28 x' │
+│      Array_Union │  4000000   │ '    950 ms' │ '    355 ms' │ '    2.68 x' │
+│  Array_Recursive │  4000000   │ '  28047 ms' │ '   9567 ms' │ '    2.93 x' │
+│    Array_Vector4 │  4000000   │ '    372 ms' │ '    200 ms' │ '    1.86 x' │
+│    Array_Matrix4 │  4000000   │ '   1521 ms' │ '   1244 ms' │ '    1.22 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
-<a name="Contribute"></a>
+
 
 ## Contribute
 

package/value/cast.d.ts

@@ -1,4 +1,8 @@
 import * as Types from '../typebox';
+export declare class ValueCastInvalidTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare namespace ValueCast {
     function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any;
     function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): Types.Static<T>;

package/value/cast.js

@@ -27,8 +27,9 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCast = void 0;
+exports.ValueCast = exports.ValueCastInvalidTypeError = void 0;
 const Types = require("../typebox");
+const index_1 = require("../guard/index");
 const create_1 = require("./create");
 const check_1 = require("./check");
 // --------------------------------------------------------------------------
@@ -71,6 +72,13 @@ var UnionValueCast;
     }
     UnionValueCast.Create = Create;
 })(UnionValueCast || (UnionValueCast = {}));
+class ValueCastInvalidTypeError extends Error {
+    constructor(schema) {
+        super('ValueCast: Invalid type');
+        this.schema = schema;
+    }
+}
+exports.ValueCastInvalidTypeError = ValueCastInvalidTypeError;
 var ValueCast;
 (function (ValueCast) {
     function Any(schema, references, value) {
@@ -189,57 +197,72 @@ var ValueCast;
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
     function Visit(schema, references, value) {
-        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
-        const anySchema = schema;
-        switch (schema[Types.Kind]) {
-            case 'Any':
-                return Any(anySchema, anyReferences, value);
-            case 'Array':
-                return Array(anySchema, anyReferences, value);
-            case 'Boolean':
-                return Boolean(anySchema, anyReferences, value);
-            case 'Constructor':
-                return Constructor(anySchema, anyReferences, value);
-            case 'Enum':
-                return Enum(anySchema, anyReferences, value);
-            case 'Function':
-                return Function(anySchema, anyReferences, value);
-            case 'Integer':
-                return Integer(anySchema, anyReferences, value);
-            case 'Literal':
-                return Literal(anySchema, anyReferences, value);
-            case 'Null':
-                return Null(anySchema, anyReferences, value);
-            case 'Number':
-                return Number(anySchema, anyReferences, value);
-            case 'Object':
-                return Object(anySchema, anyReferences, value);
-            case 'Promise':
-                return Promise(anySchema, anyReferences, value);
-            case 'Record':
-                return Record(anySchema, anyReferences, value);
-            case 'Rec':
-                return Recursive(anySchema, anyReferences, value);
-            case 'Ref':
-                return Ref(anySchema, anyReferences, value);
-            case 'Self':
-                return Self(anySchema, anyReferences, value);
-            case 'String':
-                return String(anySchema, anyReferences, value);
-            case 'Tuple':
-                return Tuple(anySchema, anyReferences, value);
-            case 'Undefined':
-                return Undefined(anySchema, anyReferences, value);
-            case 'Union':
-                return Union(anySchema, anyReferences, value);
-            case 'Uint8Array':
-                return Uint8Array(anySchema, anyReferences, value);
-            case 'Unknown':
-                return Unknown(anySchema, anyReferences, value);
-            case 'Void':
-                return Void(anySchema, anyReferences, value);
-            default:
-                throw Error(`ValueCast.Visit: Unknown schema kind '${schema[Types.Kind]}'`);
+        const refs = schema.$id === undefined ? references : [schema, ...references];
+        if (index_1.TypeGuard.TAny(schema)) {
+            return Any(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TArray(schema)) {
+            return Array(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TBoolean(schema)) {
+            return Boolean(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TConstructor(schema)) {
+            return Constructor(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TFunction(schema)) {
+            return Function(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TInteger(schema)) {
+            return Integer(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TLiteral(schema)) {
+            return Literal(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TNull(schema)) {
+            return Null(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TNumber(schema)) {
+            return Number(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TObject(schema)) {
+            return Object(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TPromise(schema)) {
+            return Promise(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TRecord(schema)) {
+            return Record(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TRef(schema)) {
+            return Ref(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TSelf(schema)) {
+            return Self(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TString(schema)) {
+            return String(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TTuple(schema)) {
+            return Tuple(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TUndefined(schema)) {
+            return Undefined(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TUnion(schema)) {
+            return Union(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TUint8Array(schema)) {
+            return Uint8Array(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TUnknown(schema)) {
+            return Unknown(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TVoid(schema)) {
+            return Void(schema, refs, value);
+        }
+        else {
+            throw new ValueCastInvalidTypeError(schema);
         }
     }
     ValueCast.Visit = Visit;

package/value/check.d.ts

@@ -1,4 +1,8 @@
 import * as Types from '../typebox';
+export declare class ValueCheckInvalidTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare namespace ValueCheck {
     function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): boolean;
 }