@sinclair/typebox 0.24.21 → 0.24.24

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,11 +513,9 @@ function test(node: Node) {
 }
 ```
 
-<a name="Generic-Types"></a>
-
 ## Generic Types
 
-Generic types can be created using functions. The following creates a generic `Nullable<T>` type. 
+Use functions to create generic types. The following creates a generic `Nullable<T>` type. 
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'
@@ -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.
@@ -594,12 +579,12 @@ type T = Static<typeof T>                            // type T = string | null
 
 //--------------------------------------------------------------------------------------------
 //
-// StringUnion<[...]>
+// StringEnum<string[]>
 //
 //--------------------------------------------------------------------------------------------
 
 function StringEnum<T extends string[]>(values: [...T]) {
-  return Type.Unsafe<T[number]>({ enum: values })
+  return Type.Unsafe<T[number]>({ type: 'string', enum: values })
 }
 
 const T = StringEnum(['A', 'B', 'C'])                // const T = {
@@ -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 │  16000000  │ '     73 ms' │ '     65 ms' │ '    1.12 x' │
-│           String │  16000000  │ '    281 ms' │ '    161 ms' │ '    1.75 x' │
-│          Boolean │  16000000  │ '    302 ms' │ '    151 ms' │ '    2.00 x' │
-│             Null │  16000000  │ '    281 ms' │ '    149 ms' │ '    1.89 x' │
-│            RegEx │  16000000  │ '    689 ms' │ '    550 ms' │ '    1.25 x' │
-│          ObjectA │  16000000  │ '    470 ms' │ '    311 ms' │ '    1.51 x' │
-│          ObjectB │  16000000  │ '    667 ms' │ '    556 ms' │ '    1.20 x' │
-│            Tuple │  16000000  │ '    362 ms' │ '    190 ms' │ '    1.91 x' │
-│            Union │  16000000  │ '    387 ms' │ '    209 ms' │ '    1.85 x' │
-│        Recursive │  16000000  │ '   6327 ms' │ '   2773 ms' │ '    2.28 x' │
-│          Vector4 │  16000000  │ '    362 ms' │ '    172 ms' │ '    2.10 x' │
-│          Matrix4 │  16000000  │ '    607 ms' │ '    418 ms' │ '    1.45 x' │
-│   Literal_String │  16000000  │ '    314 ms' │ '    151 ms' │ '    2.08 x' │
-│   Literal_Number │  16000000  │ '    281 ms' │ '    147 ms' │ '    1.91 x' │
-│  Literal_Boolean │  16000000  │ '    289 ms' │ '    148 ms' │ '    1.95 x' │
-│     Array_Number │  16000000  │ '    475 ms' │ '    230 ms' │ '    2.07 x' │
-│     Array_String │  16000000  │ '    463 ms' │ '    297 ms' │ '    1.56 x' │
-│    Array_Boolean │  16000000  │ '    521 ms' │ '    348 ms' │ '    1.50 x' │
-│    Array_ObjectA │  16000000  │ '  43842 ms' │ '  28375 ms' │ '    1.55 x' │
-│    Array_ObjectB │  16000000  │ '  45055 ms' │ '  32882 ms' │ '    1.37 x' │
-│      Array_Tuple │  16000000  │ '   1424 ms' │ '   1105 ms' │ '    1.29 x' │
-│      Array_Union │  16000000  │ '   3505 ms' │ '   1350 ms' │ '    2.60 x' │
-│  Array_Recursive │  16000000  │ ' 117087 ms' │ '  42982 ms' │ '    2.72 x' │
-│    Array_Vector4 │  16000000  │ '   1500 ms' │ '    817 ms' │ '    1.84 x' │
-│    Array_Matrix4 │  16000000  │ '   6126 ms' │ '   4965 ms' │ '    1.23 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    │ '    387 ms' │ '      7 ms' │ '   55.29 x' │
-│           String │    2000    │ '    340 ms' │ '      6 ms' │ '   56.67 x' │
-│          Boolean │    2000    │ '    314 ms' │ '      5 ms' │ '   62.80 x' │
-│             Null │    2000    │ '    259 ms' │ '      5 ms' │ '   51.80 x' │
-│            RegEx │    2000    │ '    491 ms' │ '      7 ms' │ '   70.14 x' │
-│          ObjectA │    2000    │ '   2850 ms' │ '     26 ms' │ '  109.62 x' │
-│          ObjectB │    2000    │ '   2989 ms' │ '     22 ms' │ '  135.86 x' │
-│            Tuple │    2000    │ '   1283 ms' │ '     17 ms' │ '   75.47 x' │
-│            Union │    2000    │ '   1292 ms' │ '     16 ms' │ '   80.75 x' │
-│          Vector4 │    2000    │ '   1588 ms' │ '     12 ms' │ '  132.33 x' │
-│          Matrix4 │    2000    │ '    934 ms' │ '      7 ms' │ '  133.43 x' │
-│   Literal_String │    2000    │ '    340 ms' │ '      5 ms' │ '   68.00 x' │
-│   Literal_Number │    2000    │ '    402 ms' │ '      4 ms' │ '  100.50 x' │
-│  Literal_Boolean │    2000    │ '    381 ms' │ '      6 ms' │ '   63.50 x' │
-│     Array_Number │    2000    │ '    750 ms' │ '      8 ms' │ '   93.75 x' │
-│     Array_String │    2000    │ '    760 ms' │ '      6 ms' │ '  126.67 x' │
-│    Array_Boolean │    2000    │ '    796 ms' │ '      7 ms' │ '  113.71 x' │
-│    Array_ObjectA │    2000    │ '   3617 ms' │ '     26 ms' │ '  139.12 x' │
-│    Array_ObjectB │    2000    │ '   3823 ms' │ '     26 ms' │ '  147.04 x' │
-│      Array_Tuple │    2000    │ '   2263 ms' │ '     13 ms' │ '  174.08 x' │
-│      Array_Union │    2000    │ '   1725 ms' │ '     16 ms' │ '  107.81 x' │
-│    Array_Vector4 │    2000    │ '   2445 ms' │ '     14 ms' │ '  174.64 x' │
-│    Array_Matrix4 │    2000    │ '   1638 ms' │ '     11 ms' │ '  148.91 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/typebox.js

@@ -91,7 +91,7 @@ class TypeBuilder {
         const values = Object.keys(item)
             .filter((key) => isNaN(key))
             .map((key) => item[key]);
-        const anyOf = values.map((value) => (typeof value === 'string' ? { [exports.Kind]: 'Literal', type: 'string', const: value } : { [exports.Kind]: 'Literal', type: 'number', const: value }));
+        const anyOf = values.map((value) => typeof value === 'string' ? { [exports.Kind]: 'Literal', type: 'string', const: value } : { [exports.Kind]: 'Literal', type: 'number', const: value });
         return this.Create({ ...options, [exports.Kind]: 'Union', [exports.Hint]: 'Enum', anyOf });
     }
     /** Creates a function type */
@@ -308,7 +308,9 @@ class TypeBuilder {
         const additionalItems = false;
         const minItems = items.length;
         const maxItems = items.length;
-        const schema = (items.length > 0 ? { ...options, [exports.Kind]: 'Tuple', type: 'array', items, additionalItems, minItems, maxItems } : { ...options, [exports.Kind]: 'Tuple', type: 'array', minItems, maxItems });
+        const schema = (items.length > 0
+            ? { ...options, [exports.Kind]: 'Tuple', type: 'array', items, additionalItems, minItems, maxItems }
+            : { ...options, [exports.Kind]: 'Tuple', type: 'array', minItems, maxItems });
         return this.Create(schema);
     }
     /** Creates a undefined type */

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;
 }