@sinclair/typebox 0.24.26 → 0.24.29

package/compiler/compiler.d.ts

@@ -17,7 +17,7 @@ export declare class TypeCheck<T extends Types.TSchema> {
 export declare namespace Property {
     function Check(propertyName: string): boolean;
 }
-export declare class TypeCompilerInvalidTypeError extends Error {
+export declare class TypeCompilerUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }

package/compiler/compiler.js

@@ -27,9 +27,11 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCompiler = exports.TypeCompilerInvalidTypeError = exports.Property = exports.TypeCheck = void 0;
+exports.TypeCompiler = exports.TypeCompilerUnknownTypeError = exports.Property = exports.TypeCheck = void 0;
 const index_1 = require("../errors/index");
 const index_2 = require("../guard/index");
+const index_3 = require("../format/index");
+const Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
 // -------------------------------------------------------------------
@@ -93,13 +95,13 @@ var Property;
 // -------------------------------------------------------------------
 // TypeCompiler
 // -------------------------------------------------------------------
-class TypeCompilerInvalidTypeError extends Error {
+class TypeCompilerUnknownTypeError extends Error {
     constructor(schema) {
-        super('TypeCompiler: Invalid type');
+        super('TypeCompiler: Unknown type');
         this.schema = schema;
     }
 }
-exports.TypeCompilerInvalidTypeError = TypeCompilerInvalidTypeError;
+exports.TypeCompilerUnknownTypeError = TypeCompilerUnknownTypeError;
 /** Compiles Types for Runtime Type Checking */
 var TypeCompiler;
 (function (TypeCompiler) {
@@ -145,11 +147,8 @@ var TypeCompiler;
         if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
             yield `(${value} === ${schema.const})`;
         }
-        else if (typeof schema.const === 'string') {
-            yield `(${value} === '${schema.const}')`;
-        }
         else {
-            throw Error('TypeCompiler: Literal value should be string, number or boolean');
+            yield `(${value} === '${schema.const}')`;
         }
     }
     function* Null(schema, value) {
@@ -176,7 +175,7 @@ var TypeCompiler;
             yield `(Object.keys(${value}).length <= ${schema.maxProperties})`;
         const propertyKeys = globalThis.Object.keys(schema.properties);
         if (schema.additionalProperties === false) {
-            // optimization: If the property key length matches the required keys length
+            // Optimization: If the property key length matches the required keys length
             // then we only need check that the values property key length matches that
             // of the property key length. This is because exhaustive testing for values
             // will occur in subsequent property tests.
@@ -212,6 +211,11 @@ var TypeCompiler;
         yield `(Object.values(${value}).every(value => ${expression}))`;
     }
     function* Ref(schema, value) {
+        // Reference: If we have seen this reference before we can just yield and return
+        // the function call. If this isn't the case we defer to visit to generate and
+        // set the function for subsequent passes. Consider for refactor.
+        if (names.has(schema.$ref))
+            return yield `(${CreateFunctionName(schema.$ref)}(${value}))`;
         if (!referenceMap.has(schema.$ref))
             throw Error(`TypeCompiler.Ref: Cannot de-reference schema with $id '${schema.$ref}'`);
         const reference = referenceMap.get(schema.$ref);
@@ -233,6 +237,9 @@ var TypeCompiler;
             const local = PushLocal(`new RegExp(/${schema.pattern}/);`);
             yield `(${local}.test(${value}))`;
         }
+        if (schema.format !== undefined) {
+            yield `(format('${schema.format}', ${value}))`;
+        }
     }
     function* Tuple(schema, value) {
         yield `(Array.isArray(${value}))`;
@@ -265,9 +272,9 @@ var TypeCompiler;
         yield `(${value} === null)`;
     }
     function* Visit(schema, value) {
-        // reference: referenced schemas can originate from either additional
-        // schemas or inline in the schema itself. Ideally the recursive
-        // path should align to reference path. Consider for review.
+        // Reference: Referenced schemas can originate from either additional schemas
+        // or inline in the schema itself. Ideally the recursive path should align to
+        // reference path. Consider for refactor.
         if (schema.$id && !names.has(schema.$id)) {
             names.add(schema.$id);
             const name = CreateFunctionName(schema.$id);
@@ -276,71 +283,52 @@ var TypeCompiler;
             yield `(${name}(${value}))`;
             return;
         }
-        if (index_2.TypeGuard.TAny(schema)) {
-            return yield* Any(schema, value);
-        }
-        else if (index_2.TypeGuard.TArray(schema)) {
-            return yield* Array(schema, value);
-        }
-        else if (index_2.TypeGuard.TBoolean(schema)) {
-            return yield* Boolean(schema, value);
-        }
-        else if (index_2.TypeGuard.TConstructor(schema)) {
-            return yield* Constructor(schema, value);
-        }
-        else if (index_2.TypeGuard.TFunction(schema)) {
-            return yield* Function(schema, value);
-        }
-        else if (index_2.TypeGuard.TInteger(schema)) {
-            return yield* Integer(schema, value);
-        }
-        else if (index_2.TypeGuard.TLiteral(schema)) {
-            return yield* Literal(schema, value);
-        }
-        else if (index_2.TypeGuard.TNull(schema)) {
-            return yield* Null(schema, value);
-        }
-        else if (index_2.TypeGuard.TNumber(schema)) {
-            return yield* Number(schema, value);
-        }
-        else if (index_2.TypeGuard.TObject(schema)) {
-            return yield* Object(schema, value);
-        }
-        else if (index_2.TypeGuard.TPromise(schema)) {
-            return yield* Promise(schema, value);
-        }
-        else if (index_2.TypeGuard.TRecord(schema)) {
-            return yield* Record(schema, value);
-        }
-        else if (index_2.TypeGuard.TRef(schema)) {
-            return yield* Ref(schema, value);
-        }
-        else if (index_2.TypeGuard.TSelf(schema)) {
-            return yield* Self(schema, value);
-        }
-        else if (index_2.TypeGuard.TString(schema)) {
-            return yield* String(schema, value);
-        }
-        else if (index_2.TypeGuard.TTuple(schema)) {
-            return yield* Tuple(schema, value);
-        }
-        else if (index_2.TypeGuard.TUndefined(schema)) {
-            return yield* Undefined(schema, value);
-        }
-        else if (index_2.TypeGuard.TUnion(schema)) {
-            return yield* Union(schema, value);
-        }
-        else if (index_2.TypeGuard.TUint8Array(schema)) {
-            return yield* Uint8Array(schema, value);
-        }
-        else if (index_2.TypeGuard.TUnknown(schema)) {
-            return yield* Unknown(schema, value);
-        }
-        else if (index_2.TypeGuard.TVoid(schema)) {
-            return yield* Void(schema, value);
-        }
-        else {
-            throw new TypeCompilerInvalidTypeError(schema);
+        const anySchema = schema;
+        switch (anySchema[Types.Kind]) {
+            case 'Any':
+                return yield* Any(anySchema, value);
+            case 'Array':
+                return yield* Array(anySchema, value);
+            case 'Boolean':
+                return yield* Boolean(anySchema, value);
+            case 'Constructor':
+                return yield* Constructor(anySchema, value);
+            case 'Function':
+                return yield* Function(anySchema, value);
+            case 'Integer':
+                return yield* Integer(anySchema, value);
+            case 'Literal':
+                return yield* Literal(anySchema, value);
+            case 'Null':
+                return yield* Null(anySchema, value);
+            case 'Number':
+                return yield* Number(anySchema, value);
+            case 'Object':
+                return yield* Object(anySchema, value);
+            case 'Promise':
+                return yield* Promise(anySchema, value);
+            case 'Record':
+                return yield* Record(anySchema, value);
+            case 'Ref':
+                return yield* Ref(anySchema, value);
+            case 'Self':
+                return yield* Self(anySchema, value);
+            case 'String':
+                return yield* String(anySchema, value);
+            case 'Tuple':
+                return yield* Tuple(anySchema, value);
+            case 'Undefined':
+                return yield* Undefined(anySchema, value);
+            case 'Union':
+                return yield* Union(anySchema, value);
+            case 'Uint8Array':
+                return yield* Uint8Array(anySchema, value);
+            case 'Unknown':
+                return yield* Unknown(anySchema, value);
+            case 'Void':
+                return yield* Void(anySchema, value);
+            default:
+                throw new TypeCompilerUnknownTypeError(schema);
         }
     }
     // -------------------------------------------------------------------
@@ -396,9 +384,16 @@ var TypeCompiler;
     }
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile(schema, references = []) {
+        index_2.TypeGuard.Assert(schema, references);
         const code = Build(schema, references);
-        const func = globalThis.Function(code);
-        return new TypeCheck(schema, references, func(), code);
+        const func1 = globalThis.Function('format', code);
+        const func2 = func1((format, value) => {
+            if (!index_3.Format.Has(format))
+                return false;
+            const func = index_3.Format.Get(format);
+            return func(value);
+        });
+        return new TypeCheck(schema, references, func2, code);
     }
     TypeCompiler.Compile = Compile;
 })(TypeCompiler = exports.TypeCompiler || (exports.TypeCompiler = {}));

package/conditional/conditional.js

@@ -30,7 +30,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Conditional = void 0;
 const Types = require("../typebox");
 const structural_1 = require("./structural");
-const guard_1 = require("../guard");
+const index_1 = require("../guard/index");
 /** Conditional Types */
 var Conditional;
 (function (Conditional) {
@@ -59,7 +59,7 @@ var Conditional;
     Conditional.Exclude = Exclude;
     /** (Experimental) Constructs a type by extracting from Type all union members that are assignable to Union. */
     function Extract(type, union, options = {}) {
-        if (guard_1.TypeGuard.TUnion(type)) {
+        if (index_1.TypeGuard.TUnion(type)) {
             const anyOf = type.anyOf.filter((schema) => structural_1.Structural.Check(schema, union) === structural_1.StructuralResult.True).map((schema) => Clone(schema));
             return { ...options, [Types.Kind]: 'Union', anyOf };
         }

package/errors/errors.d.ts

@@ -47,7 +47,7 @@ export interface ValueError {
     value: unknown;
     message: string;
 }
-export declare class ValueErrorsInvalidTypeError extends Error {
+export declare class ValueErrorsUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }

package/errors/errors.js

@@ -27,8 +27,8 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueErrors = exports.ValueErrorsInvalidTypeError = exports.ValueErrorType = void 0;
-const index_1 = require("../guard/index");
+exports.ValueErrors = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = void 0;
+const Types = require("../typebox");
 // -------------------------------------------------------------------
 // ValueErrorType
 // -------------------------------------------------------------------
@@ -77,13 +77,13 @@ var ValueErrorType;
 // -------------------------------------------------------------------
 // ValueErrors
 // -------------------------------------------------------------------
-class ValueErrorsInvalidTypeError extends Error {
+class ValueErrorsUnknownTypeError extends Error {
     constructor(schema) {
-        super('ValueErrors: Invalid type');
+        super('ValueErrors: Unknown type');
         this.schema = schema;
     }
 }
-exports.ValueErrorsInvalidTypeError = ValueErrorsInvalidTypeError;
+exports.ValueErrorsUnknownTypeError = ValueErrorsUnknownTypeError;
 var ValueErrors;
 (function (ValueErrors) {
     function* Any(schema, references, path, value) { }
@@ -306,72 +306,53 @@ var ValueErrors;
         }
     }
     function* Visit(schema, references, path, value) {
-        const refs = schema.$id === undefined ? references : [schema, ...references];
-        if (index_1.TypeGuard.TAny(schema)) {
-            return yield* Any(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TArray(schema)) {
-            return yield* Array(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TBoolean(schema)) {
-            return yield* Boolean(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TConstructor(schema)) {
-            return yield* Constructor(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TFunction(schema)) {
-            return yield* Function(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TInteger(schema)) {
-            return yield* Integer(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TLiteral(schema)) {
-            return yield* Literal(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TNull(schema)) {
-            return yield* Null(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TNumber(schema)) {
-            return yield* Number(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TObject(schema)) {
-            return yield* Object(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TPromise(schema)) {
-            return yield* Promise(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TRecord(schema)) {
-            return yield* Record(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TRef(schema)) {
-            return yield* Ref(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TSelf(schema)) {
-            return yield* Self(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TString(schema)) {
-            return yield* String(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TTuple(schema)) {
-            return yield* Tuple(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TUndefined(schema)) {
-            return yield* Undefined(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TUnion(schema)) {
-            return yield* Union(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TUint8Array(schema)) {
-            return yield* Uint8Array(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TUnknown(schema)) {
-            return yield* Unknown(schema, refs, path, value);
-        }
-        else if (index_1.TypeGuard.TVoid(schema)) {
-            return yield* Void(schema, refs, path, value);
-        }
-        else {
-            throw new ValueErrorsInvalidTypeError(schema);
+        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
+        const anySchema = schema;
+        switch (anySchema[Types.Kind]) {
+            case 'Any':
+                return yield* Any(anySchema, anyReferences, path, value);
+            case 'Array':
+                return yield* Array(anySchema, anyReferences, path, value);
+            case 'Boolean':
+                return yield* Boolean(anySchema, anyReferences, path, value);
+            case 'Constructor':
+                return yield* Constructor(anySchema, anyReferences, path, value);
+            case 'Function':
+                return yield* Function(anySchema, anyReferences, path, value);
+            case 'Integer':
+                return yield* Integer(anySchema, anyReferences, path, value);
+            case 'Literal':
+                return yield* Literal(anySchema, anyReferences, path, value);
+            case 'Null':
+                return yield* Null(anySchema, anyReferences, path, value);
+            case 'Number':
+                return yield* Number(anySchema, anyReferences, path, value);
+            case 'Object':
+                return yield* Object(anySchema, anyReferences, path, value);
+            case 'Promise':
+                return yield* Promise(anySchema, anyReferences, path, value);
+            case 'Record':
+                return yield* Record(anySchema, anyReferences, path, value);
+            case 'Ref':
+                return yield* Ref(anySchema, anyReferences, path, value);
+            case 'Self':
+                return yield* Self(anySchema, anyReferences, path, value);
+            case 'String':
+                return yield* String(anySchema, anyReferences, path, value);
+            case 'Tuple':
+                return yield* Tuple(anySchema, anyReferences, path, value);
+            case 'Undefined':
+                return yield* Undefined(anySchema, anyReferences, path, value);
+            case 'Union':
+                return yield* Union(anySchema, anyReferences, path, value);
+            case 'Uint8Array':
+                return yield* Uint8Array(anySchema, anyReferences, path, value);
+            case 'Unknown':
+                return yield* Unknown(anySchema, anyReferences, path, value);
+            case 'Void':
+                return yield* Void(anySchema, anyReferences, path, value);
+            default:
+                throw new ValueErrorsUnknownTypeError(schema);
         }
     }
     function* Errors(schema, references, value) {

package/format/format.d.ts

@@ -0,0 +1,12 @@
+export declare type FormatValidationFunction = (value: string) => boolean;
+/** Shared string formats used by the TypeCompiler and Value modules */
+export declare namespace Format {
+    /** Clears all formats */
+    function Clear(format: string): void;
+    /** Returns true if the string format exists */
+    function Has(format: string): boolean;
+    /** Sets a string format validation function */
+    function Set(format: string, func: FormatValidationFunction): void;
+    /** Gets a string format validation function */
+    function Get(format: string): FormatValidationFunction | undefined;
+}

package/format/format.js

@@ -0,0 +1,55 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Format = void 0;
+/** Shared string formats used by the TypeCompiler and Value modules */
+var Format;
+(function (Format) {
+    const formats = new Map();
+    /** Clears all formats */
+    function Clear(format) {
+        return formats.clear();
+    }
+    Format.Clear = Clear;
+    /** Returns true if the string format exists */
+    function Has(format) {
+        return formats.has(format);
+    }
+    Format.Has = Has;
+    /** Sets a string format validation function */
+    function Set(format, func) {
+        formats.set(format, func);
+    }
+    Format.Set = Set;
+    /** Gets a string format validation function */
+    function Get(format) {
+        return formats.get(format);
+    }
+    Format.Get = Get;
+})(Format = exports.Format || (exports.Format = {}));

package/format/index.d.ts

@@ -0,0 +1 @@
+export * from './format';

package/format/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/format
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./format"), exports);

package/guard/guard.d.ts

@@ -1,48 +1,54 @@
 import * as Types from '../typebox';
+export declare class TypeGuardInvalidTypeError extends Error {
+    readonly schema: unknown;
+    constructor(schema: unknown);
+}
 /** TypeGuard tests that values conform to a known TypeBox type specification */
 export declare namespace TypeGuard {
     /** Returns true if the given schema is TAny */
-    function TAny(schema: any): schema is Types.TAny;
+    function TAny(schema: unknown): schema is Types.TAny;
     /** Returns true if the given schema is TArray */
-    function TArray(schema: any): schema is Types.TArray;
+    function TArray(schema: unknown): schema is Types.TArray;
     /** Returns true if the given schema is TBoolean */
-    function TBoolean(schema: any): schema is Types.TBoolean;
+    function TBoolean(schema: unknown): schema is Types.TBoolean;
     /** Returns true if the given schema is TConstructor */
-    function TConstructor(schema: any): schema is Types.TConstructor;
+    function TConstructor(schema: unknown): schema is Types.TConstructor;
     /** Returns true if the given schema is TFunction */
-    function TFunction(schema: any): schema is Types.TFunction;
+    function TFunction(schema: unknown): schema is Types.TFunction;
     /** Returns true if the given schema is TInteger */
-    function TInteger(schema: any): schema is Types.TInteger;
+    function TInteger(schema: unknown): schema is Types.TInteger;
     /** Returns true if the given schema is TLiteral */
-    function TLiteral(schema: any): schema is Types.TLiteral;
+    function TLiteral(schema: unknown): schema is Types.TLiteral;
     /** Returns true if the given schema is TNull */
-    function TNull(schema: any): schema is Types.TNull;
+    function TNull(schema: unknown): schema is Types.TNull;
     /** Returns true if the given schema is TNumber */
-    function TNumber(schema: any): schema is Types.TNumber;
+    function TNumber(schema: unknown): schema is Types.TNumber;
     /** Returns true if the given schema is TObject */
-    function TObject(schema: any): schema is Types.TObject;
+    function TObject(schema: unknown): schema is Types.TObject;
     /** Returns true if the given schema is TPromise */
-    function TPromise(schema: any): schema is Types.TPromise;
+    function TPromise(schema: unknown): schema is Types.TPromise;
     /** Returns true if the given schema is TRecord */
-    function TRecord(schema: any): schema is Types.TRecord;
+    function TRecord(schema: unknown): schema is Types.TRecord;
     /** Returns true if the given schema is TSelf */
-    function TSelf(schema: any): schema is Types.TSelf;
+    function TSelf(schema: unknown): schema is Types.TSelf;
     /** Returns true if the given schema is TRef */
-    function TRef(schema: any): schema is Types.TRef;
+    function TRef(schema: unknown): schema is Types.TRef;
     /** Returns true if the given schema is TString */
-    function TString(schema: any): schema is Types.TString;
+    function TString(schema: unknown): schema is Types.TString;
     /** Returns true if the given schema is TTuple */
-    function TTuple(schema: any): schema is Types.TTuple;
+    function TTuple(schema: unknown): schema is Types.TTuple;
     /** Returns true if the given schema is TUndefined */
-    function TUndefined(schema: any): schema is Types.TUndefined;
+    function TUndefined(schema: unknown): schema is Types.TUndefined;
     /** Returns true if the given schema is TUnion */
-    function TUnion(schema: any): schema is Types.TUnion;
+    function TUnion(schema: unknown): schema is Types.TUnion;
     /** Returns true if the given schema is TUint8Array */
-    function TUint8Array(schema: any): schema is Types.TUint8Array;
+    function TUint8Array(schema: unknown): schema is Types.TUint8Array;
     /** Returns true if the given schema is TUnknown */
-    function TUnknown(schema: any): schema is Types.TUnknown;
+    function TUnknown(schema: unknown): schema is Types.TUnknown;
     /** Returns true if the given schema is TVoid */
-    function TVoid(schema: any): schema is Types.TVoid;
+    function TVoid(schema: unknown): schema is Types.TVoid;
     /** Returns true if the given schema is TSchema */
-    function TSchema(schema: any): schema is Types.TSchema;
+    function TSchema(schema: unknown): schema is Types.TSchema;
+    /** Asserts if this schema and associated references are valid. */
+    function Assert<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): void;
 }