@sinclair/typebox 0.24.7 → 0.24.10

package/value/cast.js

@@ -0,0 +1,249 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+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.ValueCast = void 0;
+const Types = require("../typebox");
+const create_1 = require("./create");
+const check_1 = require("./check");
+// --------------------------------------------------------------------------
+// Specialized Union Patch. Because a value can be one of many different
+// unions with properties potentially overlapping, we need a strategy
+// in which to resolve the appropriate schema to patch from.
+//
+// The following will score each union type found within the types anyOf
+// array. Typically this is executed for objects only, so the score is a
+// essentially a tally of how many properties are valid. The reasoning
+// here is the discriminator field would tip the scales in favor of that
+// union if other properties overlap and match.
+// --------------------------------------------------------------------------
+var UnionValueCast;
+(function (UnionValueCast) {
+    function Score(schema, references, value) {
+        let score = 0;
+        if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
+            const objectSchema = schema;
+            const entries = globalThis.Object.entries(objectSchema.properties);
+            score += entries.reduce((acc, [key, schema]) => acc + (check_1.ValueCheck.Check(schema, references, value[key]) ? 1 : 0), 0);
+        }
+        return score;
+    }
+    function Select(schema, references, value) {
+        let select = schema.anyOf[0];
+        let best = 0;
+        for (const subschema of schema.anyOf) {
+            const score = Score(subschema, references, value);
+            if (score > best) {
+                select = subschema;
+                best = score;
+            }
+        }
+        return select;
+    }
+    function Create(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : ValueCast.Cast(Select(schema, references, value), references, value);
+    }
+    UnionValueCast.Create = Create;
+})(UnionValueCast || (UnionValueCast = {}));
+var ValueCast;
+(function (ValueCast) {
+    function Any(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Array(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
+            return value;
+        if (!globalThis.Array.isArray(value))
+            return create_1.ValueCreate.Create(schema, references);
+        return value.map((val) => Visit(schema.items, references, val));
+    }
+    function Boolean(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Constructor(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
+            return create_1.ValueCreate.Create(schema, references);
+        const required = new Set(schema.returns.required || []);
+        const result = function () { };
+        for (const [key, property] of globalThis.Object.entries(schema.returns.properties)) {
+            if (!required.has(key) && value.prototype[key] === undefined)
+                continue;
+            result.prototype[key] = Visit(property, references, value.prototype[key]);
+        }
+        return result;
+    }
+    function Enum(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Function(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Integer(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Literal(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Null(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Number(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Object(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
+            return value;
+        if (value === null || typeof value !== 'object')
+            return create_1.ValueCreate.Create(schema, references);
+        const required = new Set(schema.required || []);
+        const result = {};
+        for (const [key, property] of globalThis.Object.entries(schema.properties)) {
+            if (!required.has(key) && value[key] === undefined)
+                continue;
+            result[key] = Visit(property, references, value[key]);
+        }
+        return result;
+    }
+    function Promise(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Record(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
+            return value;
+        if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value))
+            return create_1.ValueCreate.Create(schema, references);
+        const subschemaKey = globalThis.Object.keys(schema.patternProperties)[0];
+        const subschema = schema.patternProperties[subschemaKey];
+        const result = {};
+        for (const [propKey, propValue] of globalThis.Object.entries(value)) {
+            result[propKey] = Visit(subschema, references, propValue);
+        }
+        return result;
+    }
+    function Recursive(schema, references, value) {
+        throw new Error('CastValue.Recursive: Cannot cast recursive schemas');
+    }
+    function Ref(schema, references, value) {
+        const reference = references.find((reference) => reference.$id === schema.$ref);
+        if (reference === undefined)
+            throw new Error(`CastValue.Ref: Cannot find schema with $id '${schema.$ref}'.`);
+        return Visit(reference, references, value);
+    }
+    function Self(schema, references, value) {
+        const reference = references.find((reference) => reference.$id === schema.$ref);
+        if (reference === undefined)
+            throw new Error(`CastValue.Self: Cannot find schema with $id '${schema.$ref}'.`);
+        return Visit(reference, references, value);
+    }
+    function String(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Tuple(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
+            return value;
+        if (!globalThis.Array.isArray(value))
+            return create_1.ValueCreate.Create(schema, references);
+        if (schema.items === undefined)
+            return [];
+        return schema.items.map((schema, index) => Visit(schema, references, value[index]));
+    }
+    function Undefined(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Union(schema, references, value) {
+        return UnionValueCast.Create(schema, references, value);
+    }
+    function Uint8Array(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Unknown(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
+    }
+    function Void(schema, references, value) {
+        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(`Unknown schema kind '${schema[Types.Kind]}'`);
+        }
+    }
+    ValueCast.Visit = Visit;
+    function Cast(schema, references, value) {
+        return schema.$id === undefined ? Visit(schema, references, value) : Visit(schema, [schema, ...references], value);
+    }
+    ValueCast.Cast = Cast;
+})(ValueCast = exports.ValueCast || (exports.ValueCast = {}));

package/value/check.d.ts

@@ -1,5 +1,4 @@
 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;
+export declare namespace ValueCheck {
+    function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): boolean;
 }

package/value/check.js

@@ -27,206 +27,268 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CheckValue = void 0;
+exports.ValueCheck = void 0;
 const Types = require("../typebox");
-var CheckValue;
-(function (CheckValue) {
-    const referenceMap = new Map();
-    function Any(schema, value) {
+var ValueCheck;
+(function (ValueCheck) {
+    function Any(schema, references, value) {
         return true;
     }
-    function Array(schema, value) {
-        if (typeof value !== 'object' || !globalThis.Array.isArray(value))
+    function Array(schema, references, value) {
+        if (!globalThis.Array.isArray(value)) {
             return false;
-        for (let i = 0; i < value.length; i++) {
-            if (!Visit(schema.items, value[i]))
-                return false;
         }
-        return true;
+        return value.every((val) => Visit(schema.items, references, val));
     }
-    function Boolean(schema, value) {
+    function Boolean(schema, references, value) {
         return typeof value === 'boolean';
     }
-    function Constructor(schema, value) {
-        return Visit(schema.returns, value.prototype); // check return type only (as an object)
+    function Constructor(schema, references, value) {
+        return Visit(schema.returns, references, value);
     }
-    function Enum(schema, value) {
-        for (const subschema of schema.anyOf) {
-            if (subschema.const === value)
-                return true;
-        }
-        return false;
-    }
-    function Function(schema, value) {
+    function Function(schema, references, value) {
         return typeof value === 'function';
     }
-    function Integer(schema, value) {
-        return typeof value === 'number' && globalThis.Number.isInteger(value);
-    }
-    function Intersect(schema, value) {
-        return Object(schema, value);
+    function Integer(schema, references, value) {
+        if (!(typeof value === 'number')) {
+            return false;
+        }
+        if (!globalThis.Number.isInteger(value)) {
+            return false;
+        }
+        if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+            return false;
+        }
+        if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+            return false;
+        }
+        if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+            return false;
+        }
+        if (schema.minimum && !(value >= schema.minimum)) {
+            return false;
+        }
+        if (schema.maximum && !(value <= schema.maximum)) {
+            return false;
+        }
+        return true;
     }
-    function Literal(schema, value) {
-        return schema.const === value;
+    function Literal(schema, references, value) {
+        return value === schema.const;
     }
-    function Null(schema, value) {
+    function Null(schema, references, value) {
         return value === null;
     }
-    function Number(schema, value) {
-        return typeof value === 'number';
+    function Number(schema, references, value) {
+        if (!(typeof value === 'number')) {
+            return false;
+        }
+        if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+            return false;
+        }
+        if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+            return false;
+        }
+        if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+            return false;
+        }
+        if (schema.minimum && !(value >= schema.minimum)) {
+            return false;
+        }
+        if (schema.maximum && !(value <= schema.maximum)) {
+            return false;
+        }
+        return true;
     }
-    function Object(schema, value) {
-        if (typeof value !== 'object' || value === null)
+    function Object(schema, references, value) {
+        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+            return false;
+        }
+        if (schema.minProperties !== undefined && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+            return false;
+        }
+        if (schema.maxProperties !== undefined && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
             return false;
+        }
         const propertyKeys = globalThis.Object.keys(schema.properties);
         if (schema.additionalProperties === false) {
-            const valueKeys = globalThis.Object.keys(value);
-            for (const valueKey of valueKeys) {
-                if (!propertyKeys.includes(valueKey))
+            // 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.
+            if (schema.required && schema.required.length === propertyKeys.length && !(globalThis.Object.keys(value).length === propertyKeys.length)) {
+                return false;
+            }
+            else {
+                if (!globalThis.Object.keys(value).every((key) => propertyKeys.includes(key))) {
                     return false;
+                }
             }
         }
         for (const propertyKey of propertyKeys) {
             const propertySchema = schema.properties[propertyKey];
-            const propertyValue = value[propertyKey];
-            if (propertyValue === undefined && schema.required !== undefined && !schema.required.includes(propertyKey))
-                return true;
-            if (!Visit(propertySchema, propertyValue))
-                return false;
+            if (schema.required && schema.required.includes(propertyKey)) {
+                if (!Visit(propertySchema, references, value[propertyKey])) {
+                    return false;
+                }
+            }
+            else {
+                if (value[propertyKey] !== undefined) {
+                    if (!Visit(propertySchema, references, value[propertyKey])) {
+                        return false;
+                    }
+                }
+            }
         }
         return true;
     }
-    function Promise(schema, value) {
-        return typeof value === 'object' && typeof value['then'] === 'function';
+    function Promise(schema, references, value) {
+        return typeof value === 'object' && typeof value.then === 'function';
     }
-    function Record(schema, value) {
-        if (typeof value !== 'object' || value === null)
+    function Record(schema, references, value) {
+        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+            return false;
+        }
+        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
+        const regex = new RegExp(keyPattern);
+        if (!globalThis.Object.keys(value).every((key) => regex.test(key))) {
             return false;
-        const propertySchema = globalThis.Object.values(schema.patternProperties)[0];
-        for (const key of globalThis.Object.keys(value)) {
-            const propertyValue = value[key];
-            if (!Visit(propertySchema, propertyValue))
+        }
+        for (const propValue of globalThis.Object.values(value)) {
+            if (!Visit(valueSchema, references, propValue))
                 return false;
         }
         return true;
     }
-    function Recursive(schema, value) {
-        throw new Error('Cannot typeof recursive types');
+    function Ref(schema, references, value) {
+        const reference = references.find((reference) => reference.$id === schema.$ref);
+        if (reference === undefined)
+            throw new Error(`CheckValue.Ref: Cannot find schema with $id '${schema.$ref}'.`);
+        return Visit(reference, references, value);
     }
-    function Ref(schema, value) {
-        throw new Error('Cannot typeof reference types');
+    function Self(schema, references, value) {
+        const reference = references.find((reference) => reference.$id === schema.$ref);
+        if (reference === undefined)
+            throw new Error(`CheckValue.Self: Cannot find schema with $id '${schema.$ref}'.`);
+        return Visit(reference, references, value);
     }
-    function Self(schema, value) {
-        if (!referenceMap.has(schema.$ref))
-            throw new Error(`Check: Cannot locate schema with $id '${schema.$id}' for referenced type`);
-        const referenced = referenceMap.get(schema.$ref);
-        return Visit(referenced, value);
-    }
-    function String(schema, value) {
-        if (typeof value !== 'string')
+    function String(schema, references, value) {
+        if (!(typeof value === 'string')) {
             return false;
+        }
+        if (schema.minLength !== undefined) {
+            if (!(value.length >= schema.minLength))
+                return false;
+        }
+        if (schema.maxLength !== undefined) {
+            if (!(value.length <= schema.maxLength))
+                return false;
+        }
         if (schema.pattern !== undefined) {
             const regex = new RegExp(schema.pattern);
-            return value.match(regex) !== null;
+            if (!regex.test(value))
+                return false;
         }
         return true;
     }
-    function Tuple(schema, value) {
-        if (typeof value !== 'object' || !globalThis.Array.isArray(value))
+    function Tuple(schema, references, value) {
+        if (!global.Array.isArray(value)) {
             return false;
-        if (schema.items === undefined && value.length === 0)
-            return true;
-        if (schema.items === undefined)
+        }
+        if (schema.items === undefined && !(value.length === 0)) {
             return false;
-        if (value.length < schema.minItems || value.length > schema.maxItems)
+        }
+        if (!(value.length === schema.maxItems)) {
             return false;
+        }
+        if (!schema.items) {
+            return true;
+        }
         for (let i = 0; i < schema.items.length; i++) {
-            if (!Visit(schema.items[i], value[i]))
+            if (!Visit(schema.items[i], references, value[i]))
                 return false;
         }
         return true;
     }
-    function Undefined(schema, value) {
+    function Undefined(schema, references, value) {
         return value === undefined;
     }
-    function Union(schema, value) {
-        for (let i = 0; i < schema.anyOf.length; i++) {
-            if (Visit(schema.anyOf[i], value))
-                return true;
-        }
-        return false;
+    function Union(schema, references, value) {
+        return schema.anyOf.some((inner) => Visit(inner, references, value));
     }
-    function Uint8Array(schema, value) {
-        return value instanceof globalThis.Uint8Array;
+    function Uint8Array(schema, references, value) {
+        if (!(value instanceof globalThis.Uint8Array)) {
+            return false;
+        }
+        if (schema.maxByteLength && !(value.length <= schema.maxByteLength)) {
+            return false;
+        }
+        if (schema.minByteLength && !(value.length >= schema.minByteLength)) {
+            return false;
+        }
+        return true;
     }
-    function Unknown(schema, value) {
+    function Unknown(schema, references, value) {
         return true;
     }
-    function Void(schema, value) {
+    function Void(schema, references, value) {
         return value === null;
     }
-    function Visit(schema, value) {
-        if (schema.$id !== undefined)
-            referenceMap.set(schema.$id, schema);
+    function Visit(schema, references, value) {
+        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
         const anySchema = schema;
         switch (anySchema[Types.Kind]) {
             case 'Any':
-                return Any(anySchema, value);
+                return Any(anySchema, anyReferences, value);
             case 'Array':
-                return Array(anySchema, value);
+                return Array(anySchema, anyReferences, value);
             case 'Boolean':
-                return Boolean(anySchema, value);
+                return Boolean(anySchema, anyReferences, value);
             case 'Constructor':
-                return Constructor(anySchema, value);
-            case 'Enum':
-                return Enum(anySchema, value);
+                return Constructor(anySchema, anyReferences, value);
             case 'Function':
-                return Function(anySchema, value);
+                return Function(anySchema, anyReferences, value);
             case 'Integer':
-                return Integer(anySchema, value);
-            case 'Intersect':
-                return Intersect(anySchema, value);
+                return Integer(anySchema, anyReferences, value);
             case 'Literal':
-                return Literal(anySchema, value);
+                return Literal(anySchema, anyReferences, value);
             case 'Null':
-                return Null(anySchema, value);
+                return Null(anySchema, anyReferences, value);
             case 'Number':
-                return Number(anySchema, value);
+                return Number(anySchema, anyReferences, value);
             case 'Object':
-                return Object(anySchema, value);
+                return Object(anySchema, anyReferences, value);
             case 'Promise':
-                return Promise(anySchema, value);
+                return Promise(anySchema, anyReferences, value);
             case 'Record':
-                return Record(anySchema, value);
-            case 'Rec':
-                return Recursive(anySchema, value);
+                return Record(anySchema, anyReferences, value);
             case 'Ref':
-                return Ref(anySchema, value);
+                return Ref(anySchema, anyReferences, value);
             case 'Self':
-                return Self(anySchema, value);
+                return Self(anySchema, anyReferences, value);
             case 'String':
-                return String(anySchema, value);
+                return String(anySchema, anyReferences, value);
             case 'Tuple':
-                return Tuple(anySchema, value);
+                return Tuple(anySchema, anyReferences, value);
             case 'Undefined':
-                return Undefined(anySchema, value);
+                return Undefined(anySchema, anyReferences, value);
             case 'Union':
-                return Union(anySchema, value);
+                return Union(anySchema, anyReferences, value);
             case 'Uint8Array':
-                return Uint8Array(anySchema, value);
+                return Uint8Array(anySchema, anyReferences, value);
             case 'Unknown':
-                return Unknown(anySchema, value);
+                return Unknown(anySchema, anyReferences, value);
             case 'Void':
-                return Void(anySchema, value);
+                return Void(anySchema, anyReferences, value);
             default:
-                throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
+                throw new Error(`CheckValue: Unknown schema kind '${schema[Types.Kind]}'`);
         }
     }
-    CheckValue.Visit = Visit;
-    function Check(schema, value) {
-        if (referenceMap.size > 0)
-            referenceMap.clear();
-        return Visit(schema, value);
+    // -------------------------------------------------------------------------
+    // Check
+    // -------------------------------------------------------------------------
+    function Check(schema, references, value) {
+        return schema.$id === undefined ? Visit(schema, references, value) : Visit(schema, [schema, ...references], value);
     }
-    CheckValue.Check = Check;
-})(CheckValue = exports.CheckValue || (exports.CheckValue = {}));
+    ValueCheck.Check = Check;
+})(ValueCheck = exports.ValueCheck || (exports.ValueCheck = {}));

package/value/create.d.ts

@@ -1,7 +1,6 @@
 import * as Types from '../typebox';
-export declare namespace CreateValue {
+export declare namespace ValueCreate {
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
-    function Visit<T extends Types.TSchema>(schema: T): Types.Static<T>;
-    /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
-    function Create<T extends Types.TSchema>(schema: T): Types.Static<T>;
+    function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>;
+    function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T>;
 }