@sinclair/typebox 0.24.26 → 0.24.27

package/compiler/compiler.d.ts

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

package/compiler/compiler.js

@@ -27,9 +27,10 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCompiler = exports.TypeCompilerInvalidTypeError = exports.Property = exports.TypeCheck = void 0;
+exports.TypeCompiler = exports.TypeCompilerUnknownTypeError = exports.Property = exports.TypeCheck = void 0;
 const index_1 = require("../errors/index");
 const index_2 = require("../guard/index");
+const Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
 // -------------------------------------------------------------------
@@ -93,13 +94,13 @@ var Property;
 // -------------------------------------------------------------------
 // TypeCompiler
 // -------------------------------------------------------------------
-class TypeCompilerInvalidTypeError extends Error {
+class TypeCompilerUnknownTypeError extends Error {
     constructor(schema) {
-        super('TypeCompiler: Invalid type');
+        super('TypeCompiler: Unknown type');
         this.schema = schema;
     }
 }
-exports.TypeCompilerInvalidTypeError = TypeCompilerInvalidTypeError;
+exports.TypeCompilerUnknownTypeError = TypeCompilerUnknownTypeError;
 /** Compiles Types for Runtime Type Checking */
 var TypeCompiler;
 (function (TypeCompiler) {
@@ -145,11 +146,8 @@ var TypeCompiler;
         if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
             yield `(${value} === ${schema.const})`;
         }
-        else if (typeof schema.const === 'string') {
-            yield `(${value} === '${schema.const}')`;
-        }
         else {
-            throw Error('TypeCompiler: Literal value should be string, number or boolean');
+            yield `(${value} === '${schema.const}')`;
         }
     }
     function* Null(schema, value) {
@@ -276,71 +274,52 @@ var TypeCompiler;
             yield `(${name}(${value}))`;
             return;
         }
-        if (index_2.TypeGuard.TAny(schema)) {
-            return yield* Any(schema, value);
-        }
-        else if (index_2.TypeGuard.TArray(schema)) {
-            return yield* Array(schema, value);
-        }
-        else if (index_2.TypeGuard.TBoolean(schema)) {
-            return yield* Boolean(schema, value);
-        }
-        else if (index_2.TypeGuard.TConstructor(schema)) {
-            return yield* Constructor(schema, value);
-        }
-        else if (index_2.TypeGuard.TFunction(schema)) {
-            return yield* Function(schema, value);
-        }
-        else if (index_2.TypeGuard.TInteger(schema)) {
-            return yield* Integer(schema, value);
-        }
-        else if (index_2.TypeGuard.TLiteral(schema)) {
-            return yield* Literal(schema, value);
-        }
-        else if (index_2.TypeGuard.TNull(schema)) {
-            return yield* Null(schema, value);
-        }
-        else if (index_2.TypeGuard.TNumber(schema)) {
-            return yield* Number(schema, value);
-        }
-        else if (index_2.TypeGuard.TObject(schema)) {
-            return yield* Object(schema, value);
-        }
-        else if (index_2.TypeGuard.TPromise(schema)) {
-            return yield* Promise(schema, value);
-        }
-        else if (index_2.TypeGuard.TRecord(schema)) {
-            return yield* Record(schema, value);
-        }
-        else if (index_2.TypeGuard.TRef(schema)) {
-            return yield* Ref(schema, value);
-        }
-        else if (index_2.TypeGuard.TSelf(schema)) {
-            return yield* Self(schema, value);
-        }
-        else if (index_2.TypeGuard.TString(schema)) {
-            return yield* String(schema, value);
-        }
-        else if (index_2.TypeGuard.TTuple(schema)) {
-            return yield* Tuple(schema, value);
-        }
-        else if (index_2.TypeGuard.TUndefined(schema)) {
-            return yield* Undefined(schema, value);
-        }
-        else if (index_2.TypeGuard.TUnion(schema)) {
-            return yield* Union(schema, value);
-        }
-        else if (index_2.TypeGuard.TUint8Array(schema)) {
-            return yield* Uint8Array(schema, value);
-        }
-        else if (index_2.TypeGuard.TUnknown(schema)) {
-            return yield* Unknown(schema, value);
-        }
-        else if (index_2.TypeGuard.TVoid(schema)) {
-            return yield* Void(schema, value);
-        }
-        else {
-            throw new TypeCompilerInvalidTypeError(schema);
+        const anySchema = schema;
+        switch (anySchema[Types.Kind]) {
+            case 'Any':
+                return yield* Any(anySchema, value);
+            case 'Array':
+                return yield* Array(anySchema, value);
+            case 'Boolean':
+                return yield* Boolean(anySchema, value);
+            case 'Constructor':
+                return yield* Constructor(anySchema, value);
+            case 'Function':
+                return yield* Function(anySchema, value);
+            case 'Integer':
+                return yield* Integer(anySchema, value);
+            case 'Literal':
+                return yield* Literal(anySchema, value);
+            case 'Null':
+                return yield* Null(anySchema, value);
+            case 'Number':
+                return yield* Number(anySchema, value);
+            case 'Object':
+                return yield* Object(anySchema, value);
+            case 'Promise':
+                return yield* Promise(anySchema, value);
+            case 'Record':
+                return yield* Record(anySchema, value);
+            case 'Ref':
+                return yield* Ref(anySchema, value);
+            case 'Self':
+                return yield* Self(anySchema, value);
+            case 'String':
+                return yield* String(anySchema, value);
+            case 'Tuple':
+                return yield* Tuple(anySchema, value);
+            case 'Undefined':
+                return yield* Undefined(anySchema, value);
+            case 'Union':
+                return yield* Union(anySchema, value);
+            case 'Uint8Array':
+                return yield* Uint8Array(anySchema, value);
+            case 'Unknown':
+                return yield* Unknown(anySchema, value);
+            case 'Void':
+                return yield* Void(anySchema, value);
+            default:
+                throw new TypeCompilerUnknownTypeError(schema);
         }
     }
     // -------------------------------------------------------------------
@@ -396,6 +375,7 @@ var TypeCompiler;
     }
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile(schema, references = []) {
+        index_2.TypeGuard.Assert(schema, references);
         const code = Build(schema, references);
         const func = globalThis.Function(code);
         return new TypeCheck(schema, references, func(), code);

package/conditional/conditional.js

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

package/errors/errors.d.ts

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

package/errors/errors.js

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

package/guard/guard.d.ts

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

package/guard/guard.js

@@ -27,8 +27,15 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeGuard = void 0;
+exports.TypeGuard = exports.TypeGuardInvalidTypeError = void 0;
 const Types = require("../typebox");
+class TypeGuardInvalidTypeError extends Error {
+    constructor(schema) {
+        super('TypeGuard: Invalid type');
+        this.schema = schema;
+    }
+}
+exports.TypeGuardInvalidTypeError = TypeGuardInvalidTypeError;
 /** TypeGuard tests that values conform to a known TypeBox type specification */
 var TypeGuard;
 (function (TypeGuard) {
@@ -81,22 +88,29 @@ var TypeGuard;
     }
     /** Returns true if the given schema is TAny */
     function TAny(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Any';
+        return IsObject(schema) && schema[Types.Kind] === 'Any' && IsOptionalString(schema.$id);
     }
     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) && IsOptionalNumber(schema.minItems) && IsOptionalNumber(schema.maxItems) && IsOptionalBoolean(schema.uniqueItems);
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Array' &&
+            schema.type === 'array' &&
+            IsOptionalString(schema.$id) &&
+            TSchema(schema.items) &&
+            IsOptionalNumber(schema.minItems) &&
+            IsOptionalNumber(schema.maxItems) &&
+            IsOptionalBoolean(schema.uniqueItems));
     }
     TypeGuard.TArray = TArray;
     /** Returns true if the given schema is TBoolean */
     function TBoolean(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Boolean' && schema.type === 'boolean';
+        return IsObject(schema) && schema[Types.Kind] === 'Boolean' && schema.type === 'boolean' && IsOptionalString(schema.$id);
     }
     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))) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Constructor' && schema.type === 'constructor' && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
             return false;
         }
         for (const parameter of schema.parameters) {
@@ -108,7 +122,7 @@ var TypeGuard;
     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))) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Function' && schema.type === 'function' && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
             return false;
         }
         for (const parameter of schema.parameters) {
@@ -123,6 +137,7 @@ var TypeGuard;
         return (IsObject(schema) &&
             schema[Types.Kind] === 'Integer' &&
             schema.type === 'integer' &&
+            IsOptionalString(schema.$id) &&
             IsOptionalNumber(schema.multipleOf) &&
             IsOptionalNumber(schema.minimum) &&
             IsOptionalNumber(schema.maximum) &&
@@ -132,12 +147,12 @@ var TypeGuard;
     TypeGuard.TInteger = TInteger;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Literal' && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const));
+        return IsObject(schema) && schema[Types.Kind] === 'Literal' && IsOptionalString(schema.$id) && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const));
     }
     TypeGuard.TLiteral = TLiteral;
     /** Returns true if the given schema is TNull */
     function TNull(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Null' && schema.type === 'null';
+        return IsObject(schema) && schema[Types.Kind] === 'Null' && schema.type === 'null' && IsOptionalString(schema.$id);
     }
     TypeGuard.TNull = TNull;
     /** Returns true if the given schema is TNumber */
@@ -145,6 +160,7 @@ var TypeGuard;
         return (IsObject(schema) &&
             schema[Types.Kind] === 'Number' &&
             schema.type === 'number' &&
+            IsOptionalString(schema.$id) &&
             IsOptionalNumber(schema.multipleOf) &&
             IsOptionalNumber(schema.minimum) &&
             IsOptionalNumber(schema.maximum) &&
@@ -157,6 +173,7 @@ var TypeGuard;
         if (!(IsObject(schema) &&
             schema[Types.Kind] === 'Object' &&
             schema.type === 'object' &&
+            IsOptionalString(schema.$id) &&
             IsObject(schema.properties) &&
             IsOptionalBoolean(schema.additionalProperties) &&
             IsOptionalNumber(schema.minProperties) &&
@@ -174,12 +191,12 @@ var TypeGuard;
     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);
+        return IsObject(schema) && schema[Types.Kind] === 'Promise' && schema.type === 'promise' && IsOptionalString(schema.$id) && 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' && schema.additionalProperties === false && IsObject(schema.patternProperties))) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Record' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.additionalProperties === false && IsObject(schema.patternProperties))) {
             return false;
         }
         const keys = Object.keys(schema.patternProperties);
@@ -197,22 +214,29 @@ var TypeGuard;
     TypeGuard.TRecord = TRecord;
     /** Returns true if the given schema is TSelf */
     function TSelf(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Self' && IsString(schema.$ref);
+        return IsObject(schema) && schema[Types.Kind] === 'Self' && IsOptionalString(schema.$id) && IsString(schema.$ref);
     }
     TypeGuard.TSelf = TSelf;
     /** Returns true if the given schema is TRef */
     function TRef(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Ref' && IsString(schema.$ref);
+        return IsObject(schema) && schema[Types.Kind] === 'Ref' && IsOptionalString(schema.$id) && IsString(schema.$ref);
     }
     TypeGuard.TRef = TRef;
     /** Returns true if the given schema is TString */
     function TString(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'String' && schema.type === 'string' && IsOptionalNumber(schema.minLength) && IsOptionalNumber(schema.maxLength) && IsOptionalPattern(schema.pattern) && IsOptionalString(schema.format);
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'String' &&
+            schema.type === 'string' &&
+            IsOptionalString(schema.$id) &&
+            IsOptionalNumber(schema.minLength) &&
+            IsOptionalNumber(schema.maxLength) &&
+            IsOptionalPattern(schema.pattern) &&
+            IsOptionalString(schema.format));
     }
     TypeGuard.TString = TString;
     /** Returns true if the given schema is TTuple */
     function TTuple(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Tuple' && schema.type === 'array' && IsNumber(schema.minItems) && IsNumber(schema.maxItems) && schema.minItems === schema.maxItems)) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Tuple' && schema.type === 'array' && IsOptionalString(schema.$id) && IsNumber(schema.minItems) && IsNumber(schema.maxItems) && schema.minItems === schema.maxItems)) {
             return false;
         }
         if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
@@ -230,12 +254,12 @@ var TypeGuard;
     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';
+        return IsObject(schema) && schema[Types.Kind] === 'Undefined' && schema.type === 'object' && IsOptionalString(schema.$id) && 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))) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Union' && IsArray(schema.anyOf) && IsOptionalString(schema.$id))) {
             return false;
         }
         for (const inner of schema.anyOf) {
@@ -247,17 +271,23 @@ var TypeGuard;
     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' && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength);
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Uint8Array' &&
+            schema.type === 'object' &&
+            IsOptionalString(schema.$id) &&
+            schema.specialized === 'Uint8Array' &&
+            IsOptionalNumber(schema.minByteLength) &&
+            IsOptionalNumber(schema.maxByteLength));
     }
     TypeGuard.TUint8Array = TUint8Array;
     /** Returns true if the given schema is TUnknown */
     function TUnknown(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Unknown';
+        return IsObject(schema) && schema[Types.Kind] === 'Unknown' && IsOptionalString(schema.$id);
     }
     TypeGuard.TUnknown = TUnknown;
     /** Returns true if the given schema is TVoid */
     function TVoid(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Void' && schema.type === 'null';
+        return IsObject(schema) && schema[Types.Kind] === 'Void' && schema.type === 'null' && IsOptionalString(schema.$id);
     }
     TypeGuard.TVoid = TVoid;
     /** Returns true if the given schema is TSchema */
@@ -285,4 +315,14 @@ var TypeGuard;
             TVoid(schema));
     }
     TypeGuard.TSchema = TSchema;
+    /** Asserts if this schema and associated references are valid. */
+    function Assert(schema, references = []) {
+        if (!TSchema(schema))
+            throw new TypeGuardInvalidTypeError(schema);
+        for (const schema of references) {
+            if (!TSchema(schema))
+                throw new TypeGuardInvalidTypeError(schema);
+        }
+    }
+    TypeGuard.Assert = Assert;
 })(TypeGuard = exports.TypeGuard || (exports.TypeGuard = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.26",
+  "version": "0.24.27",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",