@sinclair/typebox 0.26.0-dev.4 → 0.26.0

package/compiler/compiler.d.ts

@@ -3,9 +3,10 @@ import { ValueErrorIterator } from '../errors/index';
 export type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends Types.TSchema> {
     private readonly schema;
+    private readonly references;
     private readonly checkFunc;
     private readonly code;
-    constructor(schema: T, checkFunc: CheckFunction, code: string);
+    constructor(schema: T, references: Types.TSchema[], checkFunc: CheckFunction, code: string);
     /** Returns the generated assertion code used to validate this type. */
     Code(): string;
     /** Returns an iterator for each error in this value. */
@@ -20,14 +21,18 @@ export declare class TypeCompilerUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
-export declare class TypeCompilerPreflightCheckError extends Error {
+export declare class TypeCompilerDereferenceError extends Error {
+    readonly schema: Types.TRef;
+    constructor(schema: Types.TRef);
+}
+export declare class TypeCompilerTypeGuardError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
 /** Compiles Types for Runtime Type Checking */
 export declare namespace TypeCompiler {
     /** Returns the generated assertion code used to validate this type. */
-    function Code<T extends Types.TSchema>(schema: T): string;
+    function Code<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): string;
     /** 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): TypeCheck<T>;
+    function Compile<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): TypeCheck<T>;
 }

package/compiler/compiler.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCompiler = exports.TypeCompilerPreflightCheckError = exports.TypeCompilerUnknownTypeError = exports.MemberExpression = exports.TypeCheck = void 0;
+exports.TypeCompiler = exports.TypeCompilerTypeGuardError = exports.TypeCompilerDereferenceError = exports.TypeCompilerUnknownTypeError = exports.MemberExpression = exports.TypeCheck = void 0;
 const Types = require("../typebox");
 const index_1 = require("../errors/index");
 const index_2 = require("../system/index");
@@ -36,8 +36,9 @@ const hash_1 = require("../value/hash");
 // TypeCheck
 // -------------------------------------------------------------------
 class TypeCheck {
-    constructor(schema, checkFunc, code) {
+    constructor(schema, references, checkFunc, code) {
         this.schema = schema;
+        this.references = references;
         this.checkFunc = checkFunc;
         this.code = code;
     }
@@ -47,7 +48,7 @@ class TypeCheck {
     }
     /** Returns an iterator for each error in this value. */
     Errors(value) {
-        return index_1.ValueErrors.Errors(this.schema, value);
+        return index_1.ValueErrors.Errors(this.schema, this.references, value);
     }
     /** Returns true if the value matches the compiled type. */
     Check(value) {
@@ -134,13 +135,20 @@ class TypeCompilerUnknownTypeError extends Error {
     }
 }
 exports.TypeCompilerUnknownTypeError = TypeCompilerUnknownTypeError;
-class TypeCompilerPreflightCheckError extends Error {
+class TypeCompilerDereferenceError extends Error {
     constructor(schema) {
-        super('TypeCompiler: Preflight validation check failed for given schema');
+        super(`TypeCompiler: Unable to dereference schema with $id '${schema.$ref}'`);
         this.schema = schema;
     }
 }
-exports.TypeCompilerPreflightCheckError = TypeCompilerPreflightCheckError;
+exports.TypeCompilerDereferenceError = TypeCompilerDereferenceError;
+class TypeCompilerTypeGuardError extends Error {
+    constructor(schema) {
+        super('TypeCompiler: Preflight validation check failed to guard for the given schema');
+        this.schema = schema;
+    }
+}
+exports.TypeCompilerTypeGuardError = TypeCompilerTypeGuardError;
 /** Compiles Types for Runtime Type Checking */
 var TypeCompiler;
 (function (TypeCompiler) {
@@ -153,14 +161,34 @@ var TypeCompiler;
     function IsNumber(value) {
         return typeof value === 'number' && globalThis.Number.isFinite(value);
     }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    // -------------------------------------------------------------------
+    // Overrides
+    // -------------------------------------------------------------------
+    function IsNumberCheck(value) {
+        return !index_2.TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
+    }
+    function IsObjectCheck(value) {
+        return !index_2.TypeSystem.AllowArrayObjects ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`;
+    }
+    function IsRecordCheck(value) {
+        return !index_2.TypeSystem.AllowArrayObjects
+            ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
+            : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`;
+    }
+    function IsVoidCheck(value) {
+        return index_2.TypeSystem.AllowVoidNull ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`;
+    }
     // -------------------------------------------------------------------
     // Types
     // -------------------------------------------------------------------
-    function* Any(schema, value) {
+    function* Any(schema, references, value) {
         yield 'true';
     }
-    function* Array(schema, value) {
-        const expression = CreateExpression(schema.items, 'value');
+    function* Array(schema, references, value) {
+        const expression = CreateExpression(schema.items, references, 'value');
         yield `Array.isArray(${value}) && ${value}.every(value => ${expression})`;
         if (IsNumber(schema.minItems))
             yield `${value}.length >= ${schema.minItems}`;
@@ -169,7 +197,7 @@ var TypeCompiler;
         if (schema.uniqueItems === true)
             yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`;
     }
-    function* BigInt(schema, value) {
+    function* BigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
         if (IsBigInt(schema.multipleOf))
             yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
@@ -182,13 +210,13 @@ var TypeCompiler;
         if (IsBigInt(schema.maximum))
             yield `${value} <= BigInt(${schema.maximum})`;
     }
-    function* Boolean(schema, value) {
+    function* Boolean(schema, references, value) {
         yield `typeof ${value} === 'boolean'`;
     }
-    function* Constructor(schema, value) {
-        yield* Visit(schema.returns, `${value}.prototype`);
+    function* Constructor(schema, references, value) {
+        yield* Visit(schema.returns, references, `${value}.prototype`);
     }
-    function* Date(schema, value) {
+    function* Date(schema, references, value) {
         yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
         if (IsNumber(schema.exclusiveMinimumTimestamp))
             yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`;
@@ -199,10 +227,10 @@ var TypeCompiler;
         if (IsNumber(schema.maximumTimestamp))
             yield `${value}.getTime() <= ${schema.maximumTimestamp}`;
     }
-    function* Function(schema, value) {
+    function* Function(schema, references, value) {
         yield `typeof ${value} === 'function'`;
     }
-    function* Integer(schema, value) {
+    function* Integer(schema, references, value) {
         yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
         if (IsNumber(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
@@ -215,28 +243,28 @@ var TypeCompiler;
         if (IsNumber(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
     }
-    function* Intersect(schema, value) {
+    function* Intersect(schema, references, value) {
         if (schema.unevaluatedProperties === undefined) {
-            const expressions = schema.allOf.map((schema) => CreateExpression(schema, value));
+            const expressions = schema.allOf.map((schema) => CreateExpression(schema, references, value));
             yield `${expressions.join(' && ')}`;
         }
         else if (schema.unevaluatedProperties === false) {
             // prettier-ignore
             const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ');
-            const expressions = schema.allOf.map((schema) => CreateExpression(schema, value));
+            const expressions = schema.allOf.map((schema) => CreateExpression(schema, references, value));
             const expression1 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key))`;
             yield `${expressions.join(' && ')} && ${expression1}`;
         }
         else if (typeof schema.unevaluatedProperties === 'object') {
             // prettier-ignore
             const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ');
-            const expressions = schema.allOf.map((schema) => CreateExpression(schema, value));
-            const expression1 = CreateExpression(schema.unevaluatedProperties, 'value[key]');
+            const expressions = schema.allOf.map((schema) => CreateExpression(schema, references, value));
+            const expression1 = CreateExpression(schema.unevaluatedProperties, references, 'value[key]');
             const expression2 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key) || ${expression1})`;
             yield `${expressions.join(' && ')} && ${expression2}`;
         }
     }
-    function* Literal(schema, value) {
+    function* Literal(schema, references, value) {
         if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
             yield `${value} === ${schema.const}`;
         }
@@ -244,21 +272,19 @@ var TypeCompiler;
             yield `${value} === '${schema.const}'`;
         }
     }
-    function* Never(schema, value) {
+    function* Never(schema, references, value) {
         yield `false`;
     }
-    function* Not(schema, value) {
-        const left = CreateExpression(schema.allOf[0].not, value);
-        const right = CreateExpression(schema.allOf[1], value);
+    function* Not(schema, references, value) {
+        const left = CreateExpression(schema.allOf[0].not, references, value);
+        const right = CreateExpression(schema.allOf[1], references, value);
         yield `!${left} && ${right}`;
     }
-    function* Null(schema, value) {
+    function* Null(schema, references, value) {
         yield `${value} === null`;
     }
-    function* Number(schema, value) {
-        yield `typeof ${value} === 'number'`;
-        if (!index_2.TypeSystem.AllowNaN)
-            yield `Number.isFinite(${value})`;
+    function* Number(schema, references, value) {
+        yield IsNumberCheck(value);
         if (IsNumber(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
         if (IsNumber(schema.exclusiveMinimum))
@@ -270,8 +296,8 @@ var TypeCompiler;
         if (IsNumber(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
     }
-    function* Object(schema, value) {
-        yield `(typeof ${value} === 'object' && ${value} !== null)`;
+    function* Object(schema, references, value) {
+        yield IsObjectCheck(value);
         if (!index_2.TypeSystem.AllowArrayObjects)
             yield `!Array.isArray(${value})`;
         if (IsNumber(schema.minProperties))
@@ -283,12 +309,12 @@ var TypeCompiler;
             const memberExpression = MemberExpression.Encode(value, schemaKey);
             const property = schema.properties[schemaKey];
             if (schema.required && schema.required.includes(schemaKey)) {
-                yield* Visit(property, memberExpression);
+                yield* Visit(property, references, memberExpression);
                 if (Types.ExtendsUndefined.Check(property))
                     yield `('${schemaKey}' in ${value})`;
             }
             else {
-                const expression = CreateExpression(property, memberExpression);
+                const expression = CreateExpression(property, references, memberExpression);
                 yield `('${schemaKey}' in ${value} ? ${expression} : true)`;
             }
         }
@@ -302,37 +328,39 @@ var TypeCompiler;
             }
         }
         if (typeof schema.additionalProperties === 'object') {
-            const expression = CreateExpression(schema.additionalProperties, 'value[key]');
+            const expression = CreateExpression(schema.additionalProperties, references, 'value[key]');
             const keys = `[${schemaKeys.map((key) => `'${key}'`).join(', ')}]`;
             yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
         }
     }
-    function* Promise(schema, value) {
+    function* Promise(schema, references, value) {
         yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
     }
-    function* Record(schema, value) {
-        yield `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date))`;
-        if (!index_2.TypeSystem.AllowArrayObjects)
-            yield `!Array.isArray(${value})`;
+    function* Record(schema, references, value) {
+        yield IsRecordCheck(value);
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const local = PushLocal(`new RegExp(/${keyPattern}/)`);
         yield `(Object.getOwnPropertyNames(${value}).every(key => ${local}.test(key)))`;
-        const expression = CreateExpression(valueSchema, 'value');
+        const expression = CreateExpression(valueSchema, references, 'value');
         yield `Object.values(${value}).every(value => ${expression})`;
     }
-    function* Ref(schema, value) {
+    function* Ref(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new TypeCompilerDereferenceError(schema);
+        const target = references[index];
         // 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 (state_local_function_names.has(schema.$ref))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
-        yield* Visit(Types.ReferenceRegistry.DerefOne(schema), value);
+        yield* Visit(target, references, value);
     }
-    function* Self(schema, value) {
+    function* Self(schema, references, value) {
         const func = CreateFunctionName(schema.$ref);
         yield `${func}(${value})`;
     }
-    function* String(schema, value) {
+    function* String(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
         if (IsNumber(schema.minLength))
             yield `${value}.length >= ${schema.minLength}`;
@@ -346,121 +374,117 @@ var TypeCompiler;
             yield `format('${schema.format}', ${value})`;
         }
     }
-    function* Symbol(schema, value) {
+    function* Symbol(schema, references, value) {
         yield `(typeof ${value} === 'symbol')`;
     }
-    function* Tuple(schema, value) {
+    function* Tuple(schema, references, value) {
         yield `(Array.isArray(${value}))`;
         if (schema.items === undefined)
             return yield `${value}.length === 0`;
         yield `(${value}.length === ${schema.maxItems})`;
         for (let i = 0; i < schema.items.length; i++) {
-            const expression = CreateExpression(schema.items[i], `${value}[${i}]`);
+            const expression = CreateExpression(schema.items[i], references, `${value}[${i}]`);
             yield `${expression}`;
         }
     }
-    function* Undefined(schema, value) {
+    function* Undefined(schema, references, value) {
         yield `${value} === undefined`;
     }
-    function* Union(schema, value) {
-        const expressions = schema.anyOf.map((schema) => CreateExpression(schema, value));
+    function* Union(schema, references, value) {
+        const expressions = schema.anyOf.map((schema) => CreateExpression(schema, references, value));
         yield `(${expressions.join(' || ')})`;
     }
-    function* Uint8Array(schema, value) {
+    function* Uint8Array(schema, references, value) {
         yield `${value} instanceof Uint8Array`;
         if (IsNumber(schema.maxByteLength))
             yield `(${value}.length <= ${schema.maxByteLength})`;
         if (IsNumber(schema.minByteLength))
             yield `(${value}.length >= ${schema.minByteLength})`;
     }
-    function* Unknown(schema, value) {
+    function* Unknown(schema, references, value) {
         yield 'true';
     }
-    function* Void(schema, value) {
-        if (index_2.TypeSystem.AllowVoidNull) {
-            yield `(${value} === undefined || ${value} === null)`;
-        }
-        else {
-            yield `${value} === undefined`;
-        }
+    function* Void(schema, references, value) {
+        yield IsVoidCheck(value);
     }
-    function* UserDefined(schema, value) {
+    function* UserDefined(schema, references, value) {
         const schema_key = `schema_key_${state_remote_custom_types.size}`;
         state_remote_custom_types.set(schema_key, schema);
         yield `custom('${schema[Types.Kind]}', '${schema_key}', ${value})`;
     }
-    function* Visit(schema, value) {
+    function* Visit(schema, references, value) {
+        const references_ = IsString(schema.$id) ? [...references, schema] : references;
+        const schema_ = schema;
         // 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 && !state_local_function_names.has(schema.$id)) {
+        if (IsString(schema.$id) && !state_local_function_names.has(schema.$id)) {
             state_local_function_names.add(schema.$id);
             const name = CreateFunctionName(schema.$id);
-            const body = CreateFunction(name, schema, 'value');
+            const body = CreateFunction(name, schema, references, 'value');
             PushFunction(body);
             yield `${name}(${value})`;
             return;
         }
-        const anySchema = schema;
-        switch (anySchema[Types.Kind]) {
+        switch (schema_[Types.Kind]) {
             case 'Any':
-                return yield* Any(anySchema, value);
+                return yield* Any(schema_, references_, value);
             case 'Array':
-                return yield* Array(anySchema, value);
+                return yield* Array(schema_, references_, value);
             case 'BigInt':
-                return yield* BigInt(anySchema, value);
+                return yield* BigInt(schema_, references_, value);
             case 'Boolean':
-                return yield* Boolean(anySchema, value);
+                return yield* Boolean(schema_, references_, value);
             case 'Constructor':
-                return yield* Constructor(anySchema, value);
+                return yield* Constructor(schema_, references_, value);
             case 'Date':
-                return yield* Date(anySchema, value);
+                return yield* Date(schema_, references_, value);
             case 'Function':
-                return yield* Function(anySchema, value);
+                return yield* Function(schema_, references_, value);
             case 'Integer':
-                return yield* Integer(anySchema, value);
+                return yield* Integer(schema_, references_, value);
             case 'Intersect':
-                return yield* Intersect(anySchema, value);
+                return yield* Intersect(schema_, references_, value);
             case 'Literal':
-                return yield* Literal(anySchema, value);
+                return yield* Literal(schema_, references_, value);
             case 'Never':
-                return yield* Never(anySchema, value);
+                return yield* Never(schema_, references_, value);
             case 'Not':
-                return yield* Not(anySchema, value);
+                return yield* Not(schema_, references_, value);
             case 'Null':
-                return yield* Null(anySchema, value);
+                return yield* Null(schema_, references_, value);
             case 'Number':
-                return yield* Number(anySchema, value);
+                return yield* Number(schema_, references_, value);
             case 'Object':
-                return yield* Object(anySchema, value);
+                return yield* Object(schema_, references_, value);
             case 'Promise':
-                return yield* Promise(anySchema, value);
+                return yield* Promise(schema_, references_, value);
             case 'Record':
-                return yield* Record(anySchema, value);
+                return yield* Record(schema_, references_, value);
             case 'Ref':
-                return yield* Ref(anySchema, value);
+                return yield* Ref(schema_, references_, value);
             case 'Self':
-                return yield* Self(anySchema, value);
+                return yield* Self(schema_, references_, value);
             case 'String':
-                return yield* String(anySchema, value);
+                return yield* String(schema_, references_, value);
             case 'Symbol':
-                return yield* Symbol(anySchema, value);
+                return yield* Symbol(schema_, references_, value);
             case 'Tuple':
-                return yield* Tuple(anySchema, value);
+                return yield* Tuple(schema_, references_, value);
             case 'Undefined':
-                return yield* Undefined(anySchema, value);
+                return yield* Undefined(schema_, references_, value);
             case 'Union':
-                return yield* Union(anySchema, value);
+                return yield* Union(schema_, references_, value);
             case 'Uint8Array':
-                return yield* Uint8Array(anySchema, value);
+                return yield* Uint8Array(schema_, references_, value);
             case 'Unknown':
-                return yield* Unknown(anySchema, value);
+                return yield* Unknown(schema_, references_, value);
             case 'Void':
-                return yield* Void(anySchema, value);
+                return yield* Void(schema_, references_, value);
             default:
-                if (!Types.TypeRegistry.Has(anySchema[Types.Kind]))
+                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
                     throw new TypeCompilerUnknownTypeError(schema);
-                return yield* UserDefined(anySchema, value);
+                return yield* UserDefined(schema_, references_, value);
         }
     }
     // -------------------------------------------------------------------
@@ -474,14 +498,14 @@ var TypeCompiler;
         state_local_function_names.clear();
         state_remote_custom_types.clear();
     }
-    function CreateExpression(schema, value) {
-        return `(${[...Visit(schema, value)].join(' && ')})`;
+    function CreateExpression(schema, references, value) {
+        return `(${[...Visit(schema, references, value)].join(' && ')})`;
     }
     function CreateFunctionName($id) {
         return `check_${Identifier.Encode($id)}`;
     }
-    function CreateFunction(name, schema, value) {
-        const expression = [...Visit(schema, value)].map((condition) => `    ${condition}`).join(' &&\n');
+    function CreateFunction(name, schema, references, value) {
+        const expression = [...Visit(schema, references, value)].map((condition) => `    ${condition}`).join(' &&\n');
         return `function ${name}(value) {\n  return (\n${expression}\n )\n}`;
     }
     function PushFunction(functionBody) {
@@ -498,22 +522,25 @@ var TypeCompiler;
     // -------------------------------------------------------------------
     // Compile
     // -------------------------------------------------------------------
-    function Build(schema) {
+    function Build(schema, references) {
         ResetCompiler();
-        const check = CreateFunction('check', schema, 'value');
+        const check = CreateFunction('check', schema, references, 'value');
         const locals = GetLocals();
         return `${locals.join('\n')}\nreturn ${check}`;
     }
     /** Returns the generated assertion code used to validate this type. */
-    function Code(schema) {
+    function Code(schema, references = []) {
         if (!Types.TypeGuard.TSchema(schema))
-            throw new TypeCompilerPreflightCheckError(schema);
-        return Build(schema);
+            throw new TypeCompilerTypeGuardError(schema);
+        for (const schema of references)
+            if (!Types.TypeGuard.TSchema(schema))
+                throw new TypeCompilerTypeGuardError(schema);
+        return Build(schema, references);
     }
     TypeCompiler.Code = Code;
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
-    function Compile(schema) {
-        const code = Code(schema);
+    function Compile(schema, references = []) {
+        const code = Code(schema, references);
         const custom_schemas = new Map(state_remote_custom_types);
         const compiledFunction = globalThis.Function('custom', 'format', 'hash', code);
         const checkFunction = compiledFunction((kind, schema_key, value) => {
@@ -530,7 +557,7 @@ var TypeCompiler;
         }, (value) => {
             return hash_1.ValueHash.Create(value);
         });
-        return new TypeCheck(schema, checkFunction, code);
+        return new TypeCheck(schema, references, checkFunction, code);
     }
     TypeCompiler.Compile = Compile;
 })(TypeCompiler = exports.TypeCompiler || (exports.TypeCompiler = {}));

package/errors/errors.d.ts

@@ -78,7 +78,11 @@ export declare class ValueErrorsUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export declare class ValueErrorsDereferenceError extends Error {
+    readonly schema: Types.TRef | Types.TSelf;
+    constructor(schema: Types.TRef | Types.TSelf);
+}
 /** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 export declare namespace ValueErrors {
-    function Errors<T extends Types.TSchema>(schema: T, value: any): ValueErrorIterator;
+    function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): ValueErrorIterator;
 }