@sinclair/typebox 0.24.5 → 0.24.8

package/compiler/compiler.d.ts

@@ -1,4 +1,4 @@
-import { TypeError } from './errors';
+import { ValueError } from '../value/errors';
 import * as Types from '../typebox';
 export declare type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends Types.TSchema> {
@@ -7,14 +7,14 @@ export declare class TypeCheck<T extends Types.TSchema> {
     private readonly checkFunc;
     private readonly code;
     constructor(schema: T, additional: Types.TSchema[], checkFunc: CheckFunction, code: string);
-    /** Returns the generated validation code used to validate this type */
+    /** Returns the generated validation code used to validate this type. */
     Code(): string;
-    /** Returns an iterator for each type error found in this value */
-    Errors(value: unknown): Generator<TypeError>;
+    /** Returns an iterator for each error in this value. */
+    Errors(value: unknown): IterableIterator<ValueError>;
     /** Returns true if the value matches the given type. */
     Check(value: unknown): value is Types.Static<T>;
 }
 export declare namespace TypeCompiler {
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
-    function Compile<T extends Types.TSchema>(schema: T, additional?: Types.TSchema[]): TypeCheck<T>;
+    function Compile<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): TypeCheck<T>;
 }

package/compiler/compiler.js

@@ -28,7 +28,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeCompiler = exports.TypeCheck = void 0;
-const errors_1 = require("./errors");
+const errors_1 = require("../value/errors");
 const Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
@@ -44,13 +44,13 @@ class TypeCheck {
         this.checkFunc = checkFunc;
         this.code = code;
     }
-    /** Returns the generated validation code used to validate this type */
+    /** Returns the generated validation code used to validate this type. */
     Code() {
         return this.code;
     }
-    /** Returns an iterator for each type error found in this value */
+    /** Returns an iterator for each error in this value. */
     Errors(value) {
-        return errors_1.TypeErrors.Errors(this.schema, this.additional, value);
+        return errors_1.ValueErrors.Errors(this.schema, this.additional, value);
     }
     /** Returns true if the value matches the given type. */
     Check(value) {
@@ -66,65 +66,65 @@ var TypeCompiler;
     // -------------------------------------------------------------------
     // Schemas
     // -------------------------------------------------------------------
-    function* Any(schema, path) {
+    function* Any(schema, value) {
         yield '(true)';
     }
-    function* Array(schema, path) {
+    function* Array(schema, value) {
         const expr = [...Visit(schema.items, `value`)].map((condition) => condition).join(' && ');
-        yield `(Array.isArray(${path}) && ${path}.every(value => ${expr}))`;
+        yield `(Array.isArray(${value}) && ${value}.every(value => ${expr}))`;
     }
-    function* Boolean(schema, path) {
-        yield `(typeof ${path} === 'boolean')`;
+    function* Boolean(schema, value) {
+        yield `(typeof ${value} === 'boolean')`;
     }
-    function* Constructor(schema, path) {
-        yield* Visit(schema.yields, path);
+    function* Constructor(schema, value) {
+        yield* Visit(schema.returns, value);
     }
-    function* Function(schema, path) {
-        yield `(typeof ${path} === 'function')`;
+    function* Function(schema, value) {
+        yield `(typeof ${value} === 'function')`;
     }
-    function* Integer(schema, path) {
-        yield `(typeof ${path} === 'number' && Number.isInteger(${path}))`;
+    function* Integer(schema, value) {
+        yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
         if (schema.multipleOf)
-            yield `(${path} % ${schema.multipleOf} === 0)`;
+            yield `(${value} % ${schema.multipleOf} === 0)`;
         if (schema.exclusiveMinimum)
-            yield `(${path} > ${schema.exclusiveMinimum})`;
+            yield `(${value} > ${schema.exclusiveMinimum})`;
         if (schema.exclusiveMaximum)
-            yield `(${path} < ${schema.exclusiveMaximum})`;
+            yield `(${value} < ${schema.exclusiveMaximum})`;
         if (schema.minimum)
-            yield `(${path} >= ${schema.minimum})`;
+            yield `(${value} >= ${schema.minimum})`;
         if (schema.maximum)
-            yield `(${path} <= ${schema.maximum})`;
+            yield `(${value} <= ${schema.maximum})`;
     }
-    function* Literal(schema, path) {
+    function* Literal(schema, value) {
         if (typeof schema.const === 'string') {
-            yield `(${path} === '${schema.const}')`;
+            yield `(${value} === '${schema.const}')`;
         }
         else {
-            yield `(${path} === ${schema.const})`;
+            yield `(${value} === ${schema.const})`;
         }
     }
-    function* Null(schema, path) {
-        yield `(${path} === null)`;
+    function* Null(schema, value) {
+        yield `(${value} === null)`;
     }
-    function* Number(schema, path) {
-        yield `(typeof ${path} === 'number')`;
+    function* Number(schema, value) {
+        yield `(typeof ${value} === 'number')`;
         if (schema.multipleOf)
-            yield `(${path} % ${schema.multipleOf} === 0)`;
+            yield `(${value} % ${schema.multipleOf} === 0)`;
         if (schema.exclusiveMinimum)
-            yield `(${path} > ${schema.exclusiveMinimum})`;
+            yield `(${value} > ${schema.exclusiveMinimum})`;
         if (schema.exclusiveMaximum)
-            yield `(${path} < ${schema.exclusiveMaximum})`;
+            yield `(${value} < ${schema.exclusiveMaximum})`;
         if (schema.minimum)
-            yield `(${path} >= ${schema.minimum})`;
+            yield `(${value} >= ${schema.minimum})`;
         if (schema.maximum)
-            yield `(${path} <= ${schema.maximum})`;
+            yield `(${value} <= ${schema.maximum})`;
     }
-    function* Object(schema, path) {
-        yield `(typeof ${path} === 'object' && ${path} !== null && !Array.isArray(${path}))`;
+    function* Object(schema, value) {
+        yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`;
         if (schema.minProperties !== undefined)
-            yield `(Object.keys(${path}).length >= ${schema.minProperties})`;
+            yield `(Object.keys(${value}).length >= ${schema.minProperties})`;
         if (schema.maxProperties !== undefined)
-            yield `(Object.keys(${path}).length <= ${schema.maxProperties})`;
+            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
@@ -132,36 +132,36 @@ var TypeCompiler;
             // of the property key length. This is because exhaustive testing for values
             // will occur in subsequent property tests.
             if (schema.required && schema.required.length === propertyKeys.length) {
-                yield `(Object.keys(${path}).length === ${propertyKeys.length})`;
+                yield `(Object.keys(${value}).length === ${propertyKeys.length})`;
             }
             else {
                 const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`;
-                yield `(Object.keys(${path}).every(key => ${keys}.includes(key)))`;
+                yield `(Object.keys(${value}).every(key => ${keys}.includes(key)))`;
             }
         }
         for (const propertyKey of propertyKeys) {
             const propertySchema = schema.properties[propertyKey];
             if (schema.required && schema.required.includes(propertyKey)) {
-                yield* Visit(propertySchema, `${path}.${propertyKey}`);
+                yield* Visit(propertySchema, `${value}.${propertyKey}`);
             }
             else {
-                const expr = [...Visit(propertySchema, `${path}.${propertyKey}`)].map((condition) => condition).join(' && ');
-                yield `(${path}.${propertyKey} === undefined ? true : (${expr}))`;
+                const expr = [...Visit(propertySchema, `${value}.${propertyKey}`)].map((condition) => condition).join(' && ');
+                yield `(${value}.${propertyKey} === undefined ? true : (${expr}))`;
             }
         }
     }
-    function* Promise(schema, path) {
-        yield `(typeof value === 'object' && typeof ${path}.then === 'function')`;
+    function* Promise(schema, value) {
+        yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
     }
-    function* Record(schema, path) {
-        yield `(typeof ${path} === 'object' && ${path} !== null && !Array.isArray(${path}))`;
+    function* Record(schema, value) {
+        yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`;
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const local = PushLocal(`const local = new RegExp(/${keyPattern}/)`);
-        yield `(Object.keys(${path}).every(key => ${local}.test(key)))`;
+        yield `(Object.keys(${value}).every(key => ${local}.test(key)))`;
         const expr = [...Visit(valueSchema, 'value')].map((condition) => condition).join(' && ');
-        yield `(Object.values(${path}).every(value => ${expr}))`;
+        yield `(Object.values(${value}).every(value => ${expr}))`;
     }
-    function* Ref(schema, path) {
+    function* Ref(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.
@@ -174,50 +174,50 @@ var TypeCompiler;
             PushLocal(body);
         }
         const func = CreateFunctionName(schema.$ref);
-        yield `(${func}(${path}))`;
+        yield `(${func}(${value}))`;
     }
-    function* Self(schema, path) {
+    function* Self(schema, value) {
         const func = CreateFunctionName(schema.$ref);
-        yield `(${func}(${path}))`;
+        yield `(${func}(${value}))`;
     }
-    function* String(schema, path) {
-        yield `(typeof ${path} === 'string')`;
+    function* String(schema, value) {
+        yield `(typeof ${value} === 'string')`;
         if (schema.pattern !== undefined) {
             const local = PushLocal(`const local = new RegExp('${schema.pattern}');`);
-            yield `(${local}.test(${path}))`;
+            yield `(${local}.test(${value}))`;
         }
     }
-    function* Tuple(schema, path) {
-        yield `(Array.isArray(${path}))`;
+    function* Tuple(schema, value) {
+        yield `(Array.isArray(${value}))`;
         if (schema.items === undefined)
-            return yield `(${path}.length === 0)`;
-        yield `(${path}.length === ${schema.maxItems})`;
+            return yield `(${value}.length === 0)`;
+        yield `(${value}.length === ${schema.maxItems})`;
         for (let i = 0; i < schema.items.length; i++) {
-            const expr = [...Visit(schema.items[i], `${path}[${i}]`)].map((condition) => condition).join(' && ');
+            const expr = [...Visit(schema.items[i], `${value}[${i}]`)].map((condition) => condition).join(' && ');
             yield `(${expr})`;
         }
     }
-    function* Undefined(schema, path) {
-        yield `${path} === undefined`;
+    function* Undefined(schema, value) {
+        yield `(${value} === undefined)`;
     }
-    function* Union(schema, path) {
-        const exprs = schema.anyOf.map((schema) => [...Visit(schema, path)].map((condition) => condition).join(' && '));
+    function* Union(schema, value) {
+        const exprs = schema.anyOf.map((schema) => [...Visit(schema, value)].map((condition) => condition).join(' && '));
         yield `(${exprs.join(' || ')})`;
     }
-    function* Uint8Array(schema, path) {
-        yield `(${path} instanceof Uint8Array)`;
+    function* Uint8Array(schema, value) {
+        yield `(${value} instanceof Uint8Array)`;
         if (schema.maxByteLength)
-            yield `(${path}.length <= ${schema.maxByteLength})`;
+            yield `(${value}.length <= ${schema.maxByteLength})`;
         if (schema.minByteLength)
-            yield `(${path}.length >= ${schema.minByteLength})`;
+            yield `(${value}.length >= ${schema.minByteLength})`;
     }
-    function* Unknown(schema, path) {
+    function* Unknown(schema, value) {
         yield '(true)';
     }
-    function* Void(schema, path) {
-        yield `(${path} === null)`;
+    function* Void(schema, value) {
+        yield `(${value} === null)`;
     }
-    function* Visit(schema, path) {
+    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.
@@ -227,53 +227,53 @@ var TypeCompiler;
             const name = CreateFunctionName(schema.$id);
             const body = CreateFunction(name, conditions);
             PushLocal(body);
-            yield `(${name}(${path}))`;
+            yield `(${name}(${value}))`;
             return;
         }
         const anySchema = schema;
         switch (anySchema[Types.Kind]) {
             case 'Any':
-                return yield* Any(anySchema, path);
+                return yield* Any(anySchema, value);
             case 'Array':
-                return yield* Array(anySchema, path);
+                return yield* Array(anySchema, value);
             case 'Boolean':
-                return yield* Boolean(anySchema, path);
+                return yield* Boolean(anySchema, value);
             case 'Constructor':
-                return yield* Constructor(anySchema, path);
+                return yield* Constructor(anySchema, value);
             case 'Function':
-                return yield* Function(anySchema, path);
+                return yield* Function(anySchema, value);
             case 'Integer':
-                return yield* Integer(anySchema, path);
+                return yield* Integer(anySchema, value);
             case 'Literal':
-                return yield* Literal(anySchema, path);
+                return yield* Literal(anySchema, value);
             case 'Null':
-                return yield* Null(anySchema, path);
+                return yield* Null(anySchema, value);
             case 'Number':
-                return yield* Number(anySchema, path);
+                return yield* Number(anySchema, value);
             case 'Object':
-                return yield* Object(anySchema, path);
+                return yield* Object(anySchema, value);
             case 'Promise':
-                return yield* Promise(anySchema, path);
+                return yield* Promise(anySchema, value);
             case 'Record':
-                return yield* Record(anySchema, path);
+                return yield* Record(anySchema, value);
             case 'Ref':
-                return yield* Ref(anySchema, path);
+                return yield* Ref(anySchema, value);
             case 'Self':
-                return yield* Self(anySchema, path);
+                return yield* Self(anySchema, value);
             case 'String':
-                return yield* String(anySchema, path);
+                return yield* String(anySchema, value);
             case 'Tuple':
-                return yield* Tuple(anySchema, path);
+                return yield* Tuple(anySchema, value);
             case 'Undefined':
-                return yield* Undefined(anySchema, path);
+                return yield* Undefined(anySchema, value);
             case 'Union':
-                return yield* Union(anySchema, path);
+                return yield* Union(anySchema, value);
             case 'Uint8Array':
-                return yield* Uint8Array(anySchema, path);
+                return yield* Uint8Array(anySchema, value);
             case 'Unknown':
-                return yield* Unknown(anySchema, path);
+                return yield* Unknown(anySchema, value);
             case 'Void':
-                return yield* Void(anySchema, path);
+                return yield* Void(anySchema, value);
             default:
                 throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
         }
@@ -319,18 +319,18 @@ var TypeCompiler;
     // -------------------------------------------------------------------
     // Compile
     // -------------------------------------------------------------------
-    function Build(schema, additional = []) {
+    function Build(schema, references = []) {
         ClearLocals();
-        PushReferences(additional);
+        PushReferences(references);
         const conditions = [...Visit(schema, 'value')]; // locals populated during yield
         const locals = GetLocals();
         return `${locals.join('\n')}\nreturn ${CreateFunction('check', conditions)}`;
     }
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
-    function Compile(schema, additional = []) {
-        const code = Build(schema, additional);
+    function Compile(schema, references = []) {
+        const code = Build(schema, references);
         const func = globalThis.Function(code);
-        return new TypeCheck(schema, additional, func(), code);
+        return new TypeCheck(schema, references, func(), code);
     }
     TypeCompiler.Compile = Compile;
 })(TypeCompiler = exports.TypeCompiler || (exports.TypeCompiler = {}));

package/compiler/index.d.ts

@@ -1,2 +1,2 @@
 export * from './compiler';
-export * from './errors';
+export * from '../value/errors';

package/compiler/index.js

@@ -38,4 +38,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./compiler"), exports);
-__exportStar(require("./errors"), exports);
+__exportStar(require("../value/errors"), exports);

package/guard/guard.d.ts

@@ -0,0 +1,48 @@
+import * as Types from '../typebox';
+/** Structural checks for TypeBox types */
+export declare namespace TypeGuard {
+    /** Returns true if the given schema is TAny */
+    function TAny(schema: any): schema is Types.TAny;
+    /** Returns true if the given schema is TArray */
+    function TArray(schema: any): schema is Types.TArray;
+    /** Returns true if the given schema is TBoolean */
+    function TBoolean(schema: any): schema is Types.TBoolean;
+    /** Returns true if the given schema is TConstructor */
+    function TConstructor(schema: any): schema is Types.TConstructor;
+    /** Returns true if the given schema is TFunction */
+    function TFunction(schema: any): schema is Types.TFunction;
+    /** Returns true if the given schema is TInteger */
+    function TInteger(schema: any): schema is Types.TInteger;
+    /** Returns true if the given schema is TLiteral */
+    function TLiteral(schema: any): schema is Types.TLiteral;
+    /** Returns true if the given schema is TNull */
+    function TNull(schema: any): schema is Types.TNull;
+    /** Returns true if the given schema is TNumber */
+    function TNumber(schema: any): schema is Types.TNumber;
+    /** Returns true if the given schema is TObject */
+    function TObject(schema: any): schema is Types.TObject;
+    /** Returns true if the given schema is TPromise */
+    function TPromise(schema: any): schema is Types.TPromise;
+    /** Returns true if the given schema is TRecord */
+    function TRecord(schema: any): schema is Types.TRecord;
+    /** Returns true if the given schema is TSelf */
+    function TSelf(schema: any): schema is Types.TSelf;
+    /** Returns true if the given schema is TRef */
+    function TRef(schema: any): schema is Types.TRef;
+    /** Returns true if the given schema is TString */
+    function TString(schema: any): schema is Types.TString;
+    /** Returns true if the given schema is TTuple */
+    function TTuple(schema: any): schema is Types.TTuple;
+    /** Returns true if the given schema is TUndefined */
+    function TUndefined(schema: any): schema is Types.TUndefined;
+    /** Returns true if the given schema is TUnion */
+    function TUnion(schema: any): schema is Types.TUnion;
+    /** Returns true if the given schema is TUint8Array */
+    function TUint8Array(schema: any): schema is Types.TUint8Array;
+    /** Returns true if the given schema is TUnknown */
+    function TUnknown(schema: any): schema is Types.TUnknown;
+    /** Returns true if the given schema is TVoid */
+    function TVoid(schema: any): schema is Types.TVoid;
+    /** Returns true if the given schema is TSchema */
+    function TSchema(schema: any): schema is Types.TSchema;
+}

package/guard/guard.js

@@ -0,0 +1,222 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/guard
+
+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, dTribute, 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.TypeGuard = void 0;
+const Types = require("../typebox");
+/** Structural checks for TypeBox types */
+var TypeGuard;
+(function (TypeGuard) {
+    function IsObject(schema) {
+        return typeof schema === 'object' && schema !== null && !Array.isArray(schema);
+    }
+    function IsArray(schema) {
+        return typeof schema === 'object' && schema !== null && Array.isArray(schema);
+    }
+    /** Returns true if the given schema is TAny */
+    function TAny(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Any';
+    }
+    TypeGuard.TAny = TAny;
+    /** Returns true if the given schema is TArray */
+    function TArray(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Array' && schema.type === 'array' && TSchema(schema.items);
+    }
+    TypeGuard.TArray = TArray;
+    /** Returns true if the given schema is TBoolean */
+    function TBoolean(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Boolean' && schema.type === 'boolean';
+    }
+    TypeGuard.TBoolean = TBoolean;
+    /** Returns true if the given schema is TConstructor */
+    function TConstructor(schema) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Constructor' && schema.type === 'constructor' && IsArray(schema.parameters) && TSchema(schema.returns))) {
+            return false;
+        }
+        for (const parameter of schema.parameters) {
+            if (!TSchema(parameter))
+                return false;
+        }
+        return true;
+    }
+    TypeGuard.TConstructor = TConstructor;
+    /** Returns true if the given schema is TFunction */
+    function TFunction(schema) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Function' && schema.type === 'function' && IsArray(schema.parameters) && TSchema(schema.returns))) {
+            return false;
+        }
+        for (const parameter of schema.parameters) {
+            if (!TSchema(parameter))
+                return false;
+        }
+        return true;
+    }
+    TypeGuard.TFunction = TFunction;
+    /** Returns true if the given schema is TInteger */
+    function TInteger(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Integer' && schema.type === 'integer';
+    }
+    TypeGuard.TInteger = TInteger;
+    /** Returns true if the given schema is TLiteral */
+    function TLiteral(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Literal' && (typeof schema.const === 'string' || typeof schema.const === 'number' || typeof schema.const === 'boolean');
+    }
+    TypeGuard.TLiteral = TLiteral;
+    /** Returns true if the given schema is TNull */
+    function TNull(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Null' && schema.type === 'null';
+    }
+    TypeGuard.TNull = TNull;
+    /** Returns true if the given schema is TNumber */
+    function TNumber(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Number' && schema.type === 'number';
+    }
+    TypeGuard.TNumber = TNumber;
+    /** Returns true if the given schema is TObject */
+    function TObject(schema) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Object' && schema.type === 'object' && IsObject(schema.properties))) {
+            return false;
+        }
+        for (const property of Object.values(schema.properties)) {
+            if (!TSchema(property))
+                return false;
+        }
+        return true;
+    }
+    TypeGuard.TObject = TObject;
+    /** Returns true if the given schema is TPromise */
+    function TPromise(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Promise' && schema.type === 'promise' && TSchema(schema.item);
+    }
+    TypeGuard.TPromise = TPromise;
+    /** Returns true if the given schema is TRecord */
+    function TRecord(schema) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Record' && schema.type === 'object' && IsObject(schema.patternProperties))) {
+            return false;
+        }
+        const keys = Object.keys(schema.patternProperties);
+        if (keys.length !== 1) {
+            return false;
+        }
+        if (!TSchema(schema.patternProperties[keys[0]])) {
+            return false;
+        }
+        return true;
+    }
+    TypeGuard.TRecord = TRecord;
+    /** Returns true if the given schema is TSelf */
+    function TSelf(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Self' && typeof schema.$ref === 'string';
+    }
+    TypeGuard.TSelf = TSelf;
+    /** Returns true if the given schema is TRef */
+    function TRef(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Ref' && typeof schema.$ref === 'string';
+    }
+    TypeGuard.TRef = TRef;
+    /** Returns true if the given schema is TString */
+    function TString(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'String' && schema.type === 'string';
+    }
+    TypeGuard.TString = TString;
+    /** Returns true if the given schema is TTuple */
+    function TTuple(schema) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Tuple' && schema.type === 'array' && schema.additionalItems === false && typeof schema.minItems === 'number' && typeof schema.maxItems === 'number' && schema.minItems === schema.maxItems)) {
+            return false;
+        }
+        if (schema.items === undefined && schema.minItems === 0) {
+            return true;
+        }
+        if (!IsArray(schema.items)) {
+            return false;
+        }
+        for (const inner of schema.items) {
+            if (!TSchema(inner))
+                return false;
+        }
+        return true;
+    }
+    TypeGuard.TTuple = TTuple;
+    /** Returns true if the given schema is TUndefined */
+    function TUndefined(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Undefined' && schema.type === 'object' && schema.specialized === 'Undefined';
+    }
+    TypeGuard.TUndefined = TUndefined;
+    /** Returns true if the given schema is TUnion */
+    function TUnion(schema) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Union' && IsArray(schema.anyOf))) {
+            return false;
+        }
+        for (const inner of schema.anyOf) {
+            if (!TSchema(inner))
+                return false;
+        }
+        return true;
+    }
+    TypeGuard.TUnion = TUnion;
+    /** Returns true if the given schema is TUint8Array */
+    function TUint8Array(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Uint8Array' && schema.type === 'object' && schema.specialized === 'Uint8Array';
+    }
+    TypeGuard.TUint8Array = TUint8Array;
+    /** Returns true if the given schema is TUnknown */
+    function TUnknown(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Unknown';
+    }
+    TypeGuard.TUnknown = TUnknown;
+    /** Returns true if the given schema is TVoid */
+    function TVoid(schema) {
+        return IsObject(schema) && schema[Types.Kind] === 'Void' && schema.type === 'null';
+    }
+    TypeGuard.TVoid = TVoid;
+    /** Returns true if the given schema is TSchema */
+    function TSchema(schema) {
+        return (TAny(schema) ||
+            TArray(schema) ||
+            TBoolean(schema) ||
+            TConstructor(schema) ||
+            TFunction(schema) ||
+            TInteger(schema) ||
+            TLiteral(schema) ||
+            TNull(schema) ||
+            TNumber(schema) ||
+            TObject(schema) ||
+            TPromise(schema) ||
+            TRecord(schema) ||
+            TSelf(schema) ||
+            TRef(schema) ||
+            TString(schema) ||
+            TTuple(schema) ||
+            TUndefined(schema) ||
+            TUnion(schema) ||
+            TUint8Array(schema) ||
+            TUnknown(schema) ||
+            TVoid(schema));
+    }
+    TypeGuard.TSchema = TSchema;
+})(TypeGuard = exports.TypeGuard || (exports.TypeGuard = {}));

package/guard/index.d.ts

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