@sinclair/typebox 0.23.4 → 0.24.1

package/typebox.js

@@ -1,11 +1,11 @@
 "use strict";
 /*--------------------------------------------------------------------------
 
-TypeBox: JSON Schema Type Builder with Static Type Resolution for TypeScript
+@sinclair/typebox
 
 The MIT License (MIT)
 
-Copyright (c) 2021 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+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
@@ -27,316 +27,303 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Type = exports.TypeBuilder = exports.VoidKind = exports.UndefinedKind = exports.PromiseKind = exports.FunctionKind = exports.ConstructorKind = exports.RefKind = exports.AnyKind = exports.UnknownKind = exports.NullKind = exports.BooleanKind = exports.IntegerKind = exports.NumberKind = exports.StringKind = exports.LiteralKind = exports.EnumKind = exports.ArrayKind = exports.RecordKind = exports.ObjectKind = exports.TupleKind = exports.UnionKind = exports.IntersectKind = exports.KeyOfKind = exports.NamespaceKind = exports.ReadonlyModifier = exports.OptionalModifier = exports.ReadonlyOptionalModifier = void 0;
+exports.Type = exports.TypeBuilder = exports.Modifier = exports.Kind = void 0;
 // --------------------------------------------------------------------------
-// Modifiers
+// Symbols
 // --------------------------------------------------------------------------
-exports.ReadonlyOptionalModifier = Symbol('ReadonlyOptionalModifier');
-exports.OptionalModifier = Symbol('OptionalModifier');
-exports.ReadonlyModifier = Symbol('ReadonlyModifier');
-// --------------------------------------------------------------------------
-// Schema Standard
-// --------------------------------------------------------------------------
-exports.NamespaceKind = Symbol('NamespaceKind');
-exports.KeyOfKind = Symbol('KeyOfKind');
-exports.IntersectKind = Symbol('IntersectKind');
-exports.UnionKind = Symbol('UnionKind');
-exports.TupleKind = Symbol('TupleKind');
-exports.ObjectKind = Symbol('ObjectKind');
-exports.RecordKind = Symbol('RecordKind');
-exports.ArrayKind = Symbol('ArrayKind');
-exports.EnumKind = Symbol('EnumKind');
-exports.LiteralKind = Symbol('LiteralKind');
-exports.StringKind = Symbol('StringKind');
-exports.NumberKind = Symbol('NumberKind');
-exports.IntegerKind = Symbol('IntegerKind');
-exports.BooleanKind = Symbol('BooleanKind');
-exports.NullKind = Symbol('NullKind');
-exports.UnknownKind = Symbol('UnknownKind');
-exports.AnyKind = Symbol('AnyKind');
-exports.RefKind = Symbol('RefKind');
-// --------------------------------------------------------------------------
-// Extended Schema Types
-// --------------------------------------------------------------------------
-exports.ConstructorKind = Symbol('ConstructorKind');
-exports.FunctionKind = Symbol('FunctionKind');
-exports.PromiseKind = Symbol('PromiseKind');
-exports.UndefinedKind = Symbol('UndefinedKind');
-exports.VoidKind = Symbol('VoidKind');
-// --------------------------------------------------------------------------
-// Utility
-// --------------------------------------------------------------------------
-function isObject(object) {
-    return typeof object === 'object' && object !== null && !Array.isArray(object);
-}
-function isArray(object) {
-    return typeof object === 'object' && object !== null && Array.isArray(object);
-}
-function clone(object) {
-    if (isObject(object))
-        return Object.keys(object).reduce((acc, key) => ({ ...acc, [key]: clone(object[key]) }), {});
-    if (isArray(object))
-        return object.map((item) => clone(item));
-    return object;
-}
+exports.Kind = Symbol.for('TypeBox.Kind');
+exports.Modifier = Symbol.for('TypeBox.Modifier');
 // --------------------------------------------------------------------------
 // TypeBuilder
 // --------------------------------------------------------------------------
+let TypeOrdinal = 0;
 class TypeBuilder {
-    schemas = new Map();
-    /** `Standard` Modifies an object property to be both readonly and optional */
+    // ----------------------------------------------------------------------
+    // Modifiers
+    // ----------------------------------------------------------------------
+    /** Creates a readonly optional property */
     ReadonlyOptional(item) {
-        return { ...item, modifier: exports.ReadonlyOptionalModifier };
+        return { [exports.Modifier]: 'ReadonlyOptional', ...item };
     }
-    /** `Standard` Modifies an object property to be readonly */
+    /** Creates a readonly property */
     Readonly(item) {
-        return { ...item, modifier: exports.ReadonlyModifier };
+        return { [exports.Modifier]: 'Readonly', ...item };
     }
-    /** `Standard` Modifies an object property to be optional */
+    /** Creates a optional property */
     Optional(item) {
-        return { ...item, modifier: exports.OptionalModifier };
-    }
-    /** `Standard` Creates a type type */
-    Tuple(items, options = {}) {
-        const additionalItems = false;
-        const minItems = items.length;
-        const maxItems = items.length;
-        const schema = ((items.length > 0)
-            ? { ...options, kind: exports.TupleKind, type: 'array', items, additionalItems, minItems, maxItems }
-            : { ...options, kind: exports.TupleKind, type: 'array', minItems, maxItems });
-        return this.Store(schema);
+        return { [exports.Modifier]: 'Optional', ...item };
     }
-    /** `Standard` Creates an object type with the given properties */
-    Object(properties, options = {}) {
-        const property_names = Object.keys(properties);
-        const optional = property_names.filter(name => {
-            const candidate = properties[name];
-            return (candidate.modifier &&
-                (candidate.modifier === exports.OptionalModifier ||
-                    candidate.modifier === exports.ReadonlyOptionalModifier));
-        });
-        const required_names = property_names.filter(name => !optional.includes(name));
-        const required = (required_names.length > 0) ? required_names : undefined;
-        return this.Store(((required)
-            ? { ...options, kind: exports.ObjectKind, type: 'object', properties, required }
-            : { ...options, kind: exports.ObjectKind, type: 'object', properties }));
-    }
-    /** `Standard` Creates an intersect type. */
-    Intersect(items, options = {}) {
-        return this.Store({ ...options, kind: exports.IntersectKind, type: 'object', allOf: items });
-    }
-    /** `Standard` Creates a union type */
-    Union(items, options = {}) {
-        return this.Store({ ...options, kind: exports.UnionKind, anyOf: items });
+    // ----------------------------------------------------------------------
+    // Types
+    // ----------------------------------------------------------------------
+    /** Creates a any type */
+    Any(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Any' });
     }
-    /** `Standard` Creates an array type */
+    /** Creates a array type */
     Array(items, options = {}) {
-        return this.Store({ ...options, kind: exports.ArrayKind, type: 'array', items });
+        return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items });
     }
-    /** `Standard` Creates an enum type from a TypeScript enum */
-    Enum(item, options = {}) {
-        const values = Object.keys(item).filter(key => isNaN(key)).map(key => item[key]);
-        const anyOf = values.map(value => typeof value === 'string' ? { type: 'string', const: value } : { type: 'number', const: value });
-        return this.Store({ ...options, kind: exports.EnumKind, anyOf });
+    /** Creates a boolean type */
+    Boolean(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Boolean', type: 'boolean' });
     }
-    /** `Standard` Creates a literal type. Supports string, number and boolean values only */
-    Literal(value, options = {}) {
-        return this.Store({ ...options, kind: exports.LiteralKind, const: value, type: typeof value });
+    /** Creates a constructor type */
+    Constructor(parameters, returns, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'constructor', parameters, returns });
     }
-    /** `Standard` Creates a string type */
-    String(options = {}) {
-        return this.Store({ ...options, kind: exports.StringKind, type: 'string' });
+    /** Creates a enum type */
+    Enum(item, options = {}) {
+        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 }));
+        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf });
     }
-    /** `Standard` Creates a string type from a regular expression */
-    RegEx(regex, options = {}) {
-        return this.String({ ...options, pattern: regex.source });
+    /** Creates a function type */
+    Function(parameters, returns, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Function', type: 'function', parameters, returns });
     }
-    /** `Standard` Creates a number type */
-    Number(options = {}) {
-        return this.Store({ ...options, kind: exports.NumberKind, type: 'number' });
-    }
-    /** `Standard` Creates an integer type */
+    /** Creates a integer type */
     Integer(options = {}) {
-        return this.Store({ ...options, kind: exports.IntegerKind, type: 'integer' });
+        return this.Create({ ...options, [exports.Kind]: 'Integer', type: 'integer' });
+    }
+    /** Creates a intersect type. */
+    Intersect(objects, options = {}) {
+        const isOptional = (schema) => (schema[exports.Modifier] && schema[exports.Modifier] === 'Optional') || schema[exports.Modifier] === 'ReadonlyOptional';
+        const [required, optional] = [new Set(), new Set()];
+        for (const object of objects) {
+            for (const [key, schema] of Object.entries(object.properties)) {
+                if (isOptional(schema))
+                    optional.add(key);
+            }
+        }
+        for (const object of objects) {
+            for (const key of Object.keys(object.properties)) {
+                if (!optional.has(key))
+                    required.add(key);
+            }
+        }
+        const properties = {};
+        for (const object of objects) {
+            for (const [key, schema] of Object.entries(object.properties)) {
+                delete schema[exports.Modifier];
+                properties[key] = properties[key] === undefined ? schema : { [exports.Kind]: 'Union', anyOf: [properties[key], { ...schema }] };
+            }
+        }
+        if (required.size > 0) {
+            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties, required: [...required] });
+        }
+        else {
+            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties });
+        }
     }
-    /** `Standard` Creates a boolean type */
-    Boolean(options = {}) {
-        return this.Store({ ...options, kind: exports.BooleanKind, type: 'boolean' });
+    /** Creates a keyof type */
+    KeyOf(object, options = {}) {
+        const items = Object.keys(object.properties).map((key) => this.Create({ ...options, [exports.Kind]: 'Literal', type: 'string', const: key }));
+        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: items });
     }
-    /** `Standard` Creates a null type */
-    Null(options = {}) {
-        return this.Store({ ...options, kind: exports.NullKind, type: 'null' });
+    /** Creates a literal type. */
+    Literal(value, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Literal', const: value, type: typeof value });
     }
-    /** `Standard` Creates an unknown type */
-    Unknown(options = {}) {
-        return this.Store({ ...options, kind: exports.UnknownKind });
+    /** Creates a null type */
+    Null(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Null', type: 'null' });
     }
-    /** `Standard` Creates an any type */
-    Any(options = {}) {
-        return this.Store({ ...options, kind: exports.AnyKind });
+    /** Creates a number type */
+    Number(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Number', type: 'number' });
     }
-    /** `Standard` Creates a record type */
-    Record(key, value, options = {}) {
-        const pattern = (() => {
-            switch (key.kind) {
-                case exports.UnionKind: return `^${key.anyOf.map((literal) => literal.const).join('|')}$`;
-                case exports.KeyOfKind: return `^${key.enum.join('|')}$`;
-                case exports.NumberKind: return '^(0|[1-9][0-9]*)$';
-                case exports.StringKind: return key.pattern ? key.pattern : '^.*$';
-                default: throw Error('Invalid Record Key');
-            }
-        })();
-        return this.Store({ ...options, kind: exports.RecordKind, type: 'object', patternProperties: { [pattern]: value } });
+    /** Creates an object type with the given properties */
+    Object(properties, options = {}) {
+        const property_names = Object.keys(properties);
+        const optional = property_names.filter((name) => {
+            const property = properties[name];
+            const modifier = property[exports.Modifier];
+            return modifier && (modifier === 'Optional' || modifier === 'ReadonlyOptional');
+        });
+        const required = property_names.filter((name) => !optional.includes(name));
+        if (required.length > 0) {
+            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties, required });
+        }
+        else {
+            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties });
+        }
     }
-    /** `Standard` Creates a keyof type from the given object */
-    KeyOf(object, options = {}) {
-        const source = this.Deref(object);
-        const keys = Object.keys(source.properties);
-        return this.Store({ ...options, kind: exports.KeyOfKind, type: 'string', enum: keys });
-    }
-    /** `Standard` Makes all properties in the given object type required */
-    Required(object, options = {}) {
-        const source = this.Deref(object);
-        const schema = { ...clone(source), ...options };
-        schema.required = Object.keys(schema.properties);
-        for (const key of Object.keys(schema.properties)) {
-            const property = schema.properties[key];
-            switch (property.modifier) {
-                case exports.ReadonlyOptionalModifier:
-                    property.modifier = exports.ReadonlyModifier;
+    /** Creates a new object whose properties are omitted from the given object */
+    Omit(schema, keys, options = {}) {
+        const next = { ...this.Clone(schema), ...options };
+        next.required = next.required ? next.required.filter((key) => !keys.includes(key)) : undefined;
+        for (const key of Object.keys(next.properties)) {
+            if (keys.includes(key))
+                delete next.properties[key];
+        }
+        return this.Create(next);
+    }
+    /** Creates an object type whose properties are all optional */
+    Partial(schema, options = {}) {
+        const next = { ...this.Clone(schema), ...options };
+        delete next.required;
+        for (const key of Object.keys(next.properties)) {
+            const property = next.properties[key];
+            const modifer = property[exports.Modifier];
+            switch (modifer) {
+                case 'ReadonlyOptional':
+                    property[exports.Modifier] = 'ReadonlyOptional';
                     break;
-                case exports.ReadonlyModifier:
-                    property.modifier = exports.ReadonlyModifier;
+                case 'Readonly':
+                    property[exports.Modifier] = 'ReadonlyOptional';
                     break;
-                case exports.OptionalModifier:
-                    delete property.modifier;
+                case 'Optional':
+                    property[exports.Modifier] = 'Optional';
                     break;
                 default:
-                    delete property.modifier;
+                    property[exports.Modifier] = 'Optional';
                     break;
             }
         }
-        return this.Store(schema);
-    }
-    /** `Standard` Makes all properties in the given object type optional */
-    Partial(object, options = {}) {
-        const source = this.Deref(object);
-        const schema = { ...clone(source), ...options };
-        delete schema.required;
-        for (const key of Object.keys(schema.properties)) {
-            const property = schema.properties[key];
-            switch (property.modifier) {
-                case exports.ReadonlyOptionalModifier:
-                    property.modifier = exports.ReadonlyOptionalModifier;
+        return this.Create(next);
+    }
+    /** Creates a new object whose properties are picked from the given object */
+    Pick(schema, keys, options = {}) {
+        const next = { ...this.Clone(schema), ...options };
+        next.required = next.required ? next.required.filter((key) => keys.includes(key)) : undefined;
+        for (const key of Object.keys(next.properties)) {
+            if (!keys.includes(key))
+                delete next.properties[key];
+        }
+        return this.Create(next);
+    }
+    /** Creates a promise type. This type cannot be represented in schema. */
+    Promise(item, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'promise', item });
+    }
+    /** Creates a record type */
+    Record(key, value, options = {}) {
+        // If string literal union return TObject with properties extracted from union.
+        if (key[exports.Kind] === 'Union') {
+            return this.Object(key.anyOf.reduce((acc, literal) => {
+                return { ...acc, [literal.const]: value };
+            }, {}), { ...options });
+        }
+        // otherwise return TRecord with patternProperties
+        const pattern = key[exports.Kind] === 'Number' ? '^(0|[1-9][0-9]*)$' : key[exports.Kind] === 'String' && key.pattern ? key.pattern : '^.*$';
+        return this.Create({
+            ...options,
+            [exports.Kind]: 'Record',
+            type: 'object',
+            patternProperties: { [pattern]: value },
+            additionalProperties: false,
+        });
+    }
+    /** Creates a recursive object type */
+    Recursive(callback, options = {}) {
+        if (options.$id === undefined)
+            options.$id = `type-${TypeOrdinal++}`;
+        const self = callback({ [exports.Kind]: 'Self', $ref: `${options.$id}` });
+        self.$id = options.$id;
+        return this.Create({ ...options, ...self });
+    }
+    /** Creates a reference schema */
+    Ref(schema, options = {}) {
+        if (schema.$id === undefined)
+            throw Error('Cannot create reference schema as target schema as has no $id');
+        return this.Create({ ...options, [exports.Kind]: 'Ref', $ref: schema.$id });
+    }
+    /** Creates a string type from a regular expression */
+    RegEx(regex, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'String', type: 'string', pattern: regex.source });
+    }
+    /** Creates an object type whose properties are all required */
+    Required(schema, options = {}) {
+        const next = { ...this.Clone(schema), ...options };
+        next.required = Object.keys(next.properties);
+        for (const key of Object.keys(next.properties)) {
+            const property = next.properties[key];
+            const modifier = property[exports.Modifier];
+            switch (modifier) {
+                case 'ReadonlyOptional':
+                    property[exports.Modifier] = 'Readonly';
                     break;
-                case exports.ReadonlyModifier:
-                    property.modifier = exports.ReadonlyOptionalModifier;
+                case 'Readonly':
+                    property[exports.Modifier] = 'Readonly';
                     break;
-                case exports.OptionalModifier:
-                    property.modifier = exports.OptionalModifier;
+                case 'Optional':
+                    delete property[exports.Modifier];
                     break;
                 default:
-                    property.modifier = exports.OptionalModifier;
+                    delete property[exports.Modifier];
                     break;
             }
         }
-        return this.Store(schema);
-    }
-    /** `Standard` Picks property keys from the given object type */
-    Pick(object, keys, options = {}) {
-        const source = this.Deref(object);
-        const schema = { ...clone(source), ...options };
-        schema.required = schema.required ? schema.required.filter((key) => keys.includes(key)) : undefined;
-        for (const key of Object.keys(schema.properties)) {
-            if (!keys.includes(key))
-                delete schema.properties[key];
-        }
-        return this.Store(schema);
-    }
-    /** `Standard` Omits property keys from the given object type */
-    Omit(object, keys, options = {}) {
-        const source = this.Deref(object);
-        const schema = { ...clone(source), ...options };
-        schema.required = schema.required ? schema.required.filter((key) => !keys.includes(key)) : undefined;
-        for (const key of Object.keys(schema.properties)) {
-            if (keys.includes(key))
-                delete schema.properties[key];
-        }
-        return this.Store(schema);
-    }
-    /** `Standard` Omits the `kind` and `modifier` properties from the underlying schema */
-    Strict(schema, options = {}) {
-        return JSON.parse(JSON.stringify({ ...options, ...schema }));
+        return this.Create(next);
     }
-    /** `Extended` Creates a constructor type */
-    Constructor(args, returns, options = {}) {
-        return this.Store({ ...options, kind: exports.ConstructorKind, type: 'constructor', arguments: args, returns });
+    /** Removes Kind and Modifier symbol property keys from this schema */
+    Strict(schema) {
+        return JSON.parse(JSON.stringify(schema));
     }
-    /** `Extended` Creates a function type */
-    Function(args, returns, options = {}) {
-        return this.Store({ ...options, kind: exports.FunctionKind, type: 'function', arguments: args, returns });
+    /** Creates a string type */
+    String(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'String', type: 'string' });
     }
-    /** `Extended` Creates a promise type */
-    Promise(item, options = {}) {
-        return this.Store({ ...options, type: 'promise', kind: exports.PromiseKind, item });
+    /** Creates a tuple type */
+    Tuple(items, options = {}) {
+        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 });
+        return this.Create(schema);
     }
-    /** `Extended` Creates a undefined type */
+    /** Creates a undefined type */
     Undefined(options = {}) {
-        return this.Store({ ...options, type: 'undefined', kind: exports.UndefinedKind });
+        return this.Create({ ...options, [exports.Kind]: 'Undefined', type: 'object', specialized: 'Undefined' });
+    }
+    /** Creates a union type */
+    Union(items, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: items });
     }
-    /** `Extended` Creates a void type */
+    /** Creates a Uint8Array type */
+    Uint8Array(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Uint8Array', type: 'object', specialized: 'Uint8Array' });
+    }
+    /** Creates an unknown type */
+    Unknown(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Unknown' });
+    }
+    /** Creates a user defined schema that infers as type T  */
+    Unsafe(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Unknown' });
+    }
+    /** Creates a void type */
     Void(options = {}) {
-        return this.Store({ ...options, type: 'void', kind: exports.VoidKind });
-    }
-    /** `Standard` Creates a namespace for a set of related types */
-    Namespace($defs, options = {}) {
-        return this.Store({ ...options, kind: exports.NamespaceKind, $defs });
-    }
-    Ref(...args) {
-        if (args.length === 2) {
-            const namespace = args[0];
-            const targetKey = args[1];
-            if (namespace.$id === undefined)
-                throw new Error(`Referenced namespace has no $id`);
-            if (!this.schemas.has(namespace.$id))
-                throw new Error(`Unable to locate namespace with $id '${namespace.$id}'`);
-            return this.Store({ kind: exports.RefKind, $ref: `${namespace.$id}#/$defs/${targetKey}` });
+        return this.Create({ ...options, [exports.Kind]: 'Void', type: 'null' });
+    }
+    /** Use this function to return TSchema with static and params omitted */
+    Create(schema) {
+        return schema;
+    }
+    /** Clones the given value */
+    Clone(value) {
+        const isObject = (object) => typeof object === 'object' && object !== null && !Array.isArray(object);
+        const isArray = (object) => typeof object === 'object' && object !== null && Array.isArray(object);
+        if (isObject(value)) {
+            return Object.keys(value).reduce((acc, key) => ({
+                ...acc,
+                [key]: this.Clone(value[key]),
+            }), Object.getOwnPropertySymbols(value).reduce((acc, key) => ({
+                ...acc,
+                [key]: this.Clone(value[key]),
+            }), {}));
         }
-        else if (args.length === 1) {
-            const target = args[0];
-            if (target.$id === undefined)
-                throw new Error(`Referenced schema has no $id`);
-            if (!this.schemas.has(target.$id))
-                throw new Error(`Unable to locate schema with $id '${target.$id}'`);
-            return this.Store({ kind: exports.RefKind, $ref: target.$id });
+        else if (isArray(value)) {
+            return value.map((item) => this.Clone(item));
         }
         else {
-            throw new Error('Type.Ref: Invalid arguments');
+            return value;
         }
     }
-    /** `Experimental` Creates a recursive type */
-    Rec(callback, options = {}) {
-        const $id = options.$id || '';
-        const self = callback({ $ref: `${$id}#/$defs/self` });
-        return this.Store({ ...options, $ref: `${$id}#/$defs/self`, $defs: { self } });
-    }
-    /** Conditionally stores and schema if it contains an $id and returns  */
-    Store(schema) {
-        const $schema = schema;
-        if (!$schema['$id'])
-            return $schema;
-        this.schemas.set($schema['$id'], $schema);
-        return $schema;
-    }
-    /** Conditionally dereferences a schema if RefKind. Otherwise return argument */
-    Deref(schema) {
-        const $schema = schema;
-        if ($schema['kind'] !== exports.RefKind)
-            return schema;
-        if (!this.schemas.has($schema['$ref']))
-            throw Error(`Unable to locate schema with $id '${$schema['$ref']}'`);
-        return this.Deref(this.schemas.get($schema['$ref']));
-    }
 }
 exports.TypeBuilder = TypeBuilder;
+/** JSON Schema Type Builder with Static Type Resolution for TypeScript */
 exports.Type = new TypeBuilder();

package/value/check.d.ts

@@ -0,0 +1,5 @@
+import * as Types from '../typebox';
+export declare namespace CheckValue {
+    function Visit<T extends Types.TSchema>(schema: T, value: any): boolean;
+    function Check<T extends Types.TSchema>(schema: T, value: any): boolean;
+}