@sinclair/typebox 0.25.8 → 0.25.10

package/compiler/compiler.d.ts

@@ -1,6 +1,6 @@
 import { ValueError } from '../errors/index';
 import * as Types from '../typebox';
-export declare type CheckFunction = (value: unknown) => boolean;
+export type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends Types.TSchema> {
     private readonly schema;
     private readonly references;

package/compiler/compiler.js

@@ -31,6 +31,7 @@ exports.TypeCompiler = exports.TypeCompilerUnknownTypeError = exports.Property =
 const index_1 = require("../errors/index");
 const index_2 = require("../guard/index");
 const index_3 = require("../format/index");
+const index_4 = require("../custom/index");
 const Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
@@ -236,11 +237,11 @@ var TypeCompiler;
         // 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 (names.has(schema.$ref))
+        if (state_local_function_names.has(schema.$ref))
             return yield `(${CreateFunctionName(schema.$ref)}(${value}))`;
-        if (!referenceMap.has(schema.$ref))
+        if (!state_reference_map.has(schema.$ref))
             throw Error(`TypeCompiler.Ref: Cannot de-reference schema with $id '${schema.$ref}'`);
-        const reference = referenceMap.get(schema.$ref);
+        const reference = state_reference_map.get(schema.$ref);
         yield* Visit(reference, value);
     }
     function* Self(schema, value) {
@@ -291,12 +292,17 @@ var TypeCompiler;
     function* Void(schema, value) {
         yield `(${value} === null)`;
     }
+    function* UserDefined(schema, 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) {
         // 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 && !names.has(schema.$id)) {
-            names.add(schema.$id);
+        if (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');
             PushFunction(body);
@@ -352,27 +358,31 @@ var TypeCompiler;
             case 'Void':
                 return yield* Void(anySchema, value);
             default:
-                throw new TypeCompilerUnknownTypeError(schema);
+                if (!index_4.Custom.Has(anySchema[Types.Kind]))
+                    throw new TypeCompilerUnknownTypeError(schema);
+                return yield* UserDefined(anySchema, value);
         }
     }
     // -------------------------------------------------------------------
-    // Compile State
+    // Compiler State
     // -------------------------------------------------------------------
-    const referenceMap = new Map();
-    const locals = new Set(); // local variables and functions
-    const names = new Set(); // cache of local functions
+    const state_reference_map = new Map(); // tracks schemas with identifiers
+    const state_local_variables = new Set(); // local variables and functions
+    const state_local_function_names = new Set(); // local function names used call ref validators
+    const state_remote_custom_types = new Map(); // remote custom types used during compilation
     function ResetCompiler() {
-        referenceMap.clear();
-        locals.clear();
-        names.clear();
+        state_reference_map.clear();
+        state_local_variables.clear();
+        state_local_function_names.clear();
+        state_remote_custom_types.clear();
     }
     function AddReferences(schemas = []) {
         for (const schema of schemas) {
             if (!schema.$id)
                 throw new Error(`TypeCompiler: Referenced schemas must specify an $id.`);
-            if (referenceMap.has(schema.$id))
+            if (state_reference_map.has(schema.$id))
                 throw new Error(`TypeCompiler: Duplicate schema $id found for '${schema.$id}'`);
-            referenceMap.set(schema.$id, schema);
+            state_reference_map.set(schema.$id, schema);
         }
     }
     function CreateExpression(schema, value) {
@@ -386,15 +396,15 @@ var TypeCompiler;
         return `function ${name}(value) {\n  return (\n${expression}\n )\n}`;
     }
     function PushFunction(functionBody) {
-        locals.add(functionBody);
+        state_local_variables.add(functionBody);
     }
     function PushLocal(expression) {
-        const local = `local_${locals.size}`;
-        locals.add(`const ${local} = ${expression}`);
+        const local = `local_${state_local_variables.size}`;
+        state_local_variables.add(`const ${local} = ${expression}`);
         return local;
     }
     function GetLocals() {
-        return [...locals.values()];
+        return [...state_local_variables.values()];
     }
     // -------------------------------------------------------------------
     // Compile
@@ -410,14 +420,21 @@ var TypeCompiler;
     function Compile(schema, references = []) {
         index_2.TypeGuard.Assert(schema, references);
         const code = Build(schema, references);
-        const func1 = globalThis.Function('format', code);
-        const func2 = func1((format, value) => {
+        const custom_schemas = new Map(state_remote_custom_types);
+        const compiledFunction = globalThis.Function('custom', 'format', code);
+        const checkFunction = compiledFunction((kind, schema_key, value) => {
+            if (!index_4.Custom.Has(kind) || !custom_schemas.has(schema_key))
+                return false;
+            const schema = custom_schemas.get(schema_key);
+            const func = index_4.Custom.Get(kind);
+            return func(schema, value);
+        }, (format, value) => {
             if (!index_3.Format.Has(format))
                 return false;
             const func = index_3.Format.Get(format);
             return func(value);
         });
-        return new TypeCheck(schema, references, func2, code);
+        return new TypeCheck(schema, references, checkFunction, code);
     }
     TypeCompiler.Compile = Compile;
 })(TypeCompiler = exports.TypeCompiler || (exports.TypeCompiler = {}));

package/conditional/conditional.d.ts

@@ -1,5 +1,5 @@
 import * as Types from '../typebox';
-export declare type TExtends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema> = Types.Static<L> extends Types.Static<R> ? T : U;
+export type TExtends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema> = Types.Static<L> extends Types.Static<R> ? T : U;
 export interface TExclude<T extends Types.TUnion, U extends Types.TUnion> extends Types.TUnion<any[]> {
     static: Exclude<Types.Static<T, this['params']>, Types.Static<U, this['params']>>;
 }

package/conditional/structural.js

@@ -49,14 +49,16 @@ var Structural;
     // ------------------------------------------------------------------------
     // Rules
     // ------------------------------------------------------------------------
-    function AnyOrUnknownRule(right) {
+    function AnyUnknownOrCustomRule(right) {
         // https://github.com/microsoft/TypeScript/issues/40049
-        if (right[Types.Kind] === 'Union' && right.anyOf.some((schema) => schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown'))
+        if (guard_1.TypeGuard.TUnion(right) && right.anyOf.some((schema) => schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown'))
             return true;
-        if (right[Types.Kind] === 'Unknown')
+        if (guard_1.TypeGuard.TUnknown(right))
             return true;
-        if (right[Types.Kind] === 'Any')
+        if (guard_1.TypeGuard.TAny(right))
             return true;
+        if (guard_1.TypeGuard.TUserDefined(right))
+            throw Error(`Structural: Cannot structurally compare custom type '${right[Types.Kind]}'`);
         return false;
     }
     function ObjectRightRule(left, right) {
@@ -132,10 +134,10 @@ var Structural;
     // Checks
     // ------------------------------------------------------------------------
     function Any(left, right) {
-        return AnyOrUnknownRule(right) ? StructuralResult.True : StructuralResult.Union;
+        return AnyUnknownOrCustomRule(right) ? StructuralResult.True : StructuralResult.Union;
     }
     function Array(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right)) {
@@ -163,7 +165,7 @@ var Structural;
         }
     }
     function Boolean(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -180,7 +182,7 @@ var Structural;
         }
     }
     function Constructor(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && globalThis.Object.keys(right.properties).length === 0) {
@@ -205,7 +207,7 @@ var Structural;
         }
     }
     function Date(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -225,7 +227,7 @@ var Structural;
         }
     }
     function Function(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right)) {
@@ -254,7 +256,7 @@ var Structural;
         }
     }
     function Integer(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -271,7 +273,7 @@ var Structural;
         }
     }
     function Literal(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -308,7 +310,7 @@ var Structural;
         }
     }
     function Number(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -328,7 +330,7 @@ var Structural;
         }
     }
     function Null(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TNull(right)) {
@@ -356,7 +358,7 @@ var Structural;
         return StructuralResult.True;
     }
     function Object(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right)) {
@@ -375,7 +377,7 @@ var Structural;
         }
     }
     function Promise(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right)) {
@@ -395,7 +397,7 @@ var Structural;
         }
     }
     function Record(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right)) {
@@ -444,7 +446,7 @@ var Structural;
         return Visit(resolved, right);
     }
     function String(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -464,7 +466,7 @@ var Structural;
         }
     }
     function Tuple(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right)) {
@@ -508,7 +510,7 @@ var Structural;
         return StructuralResult.True;
     }
     function Uint8Array(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TObject(right) && ObjectRightRule(left, right)) {
@@ -528,7 +530,7 @@ var Structural;
         }
     }
     function Undefined(left, right) {
-        if (AnyOrUnknownRule(right)) {
+        if (AnyUnknownOrCustomRule(right)) {
             return StructuralResult.True;
         }
         else if (guard_1.TypeGuard.TUndefined(right)) {
@@ -666,6 +668,9 @@ var Structural;
         else if (guard_1.TypeGuard.TVoid(left)) {
             return Void(left, resolvedRight);
         }
+        else if (guard_1.TypeGuard.TUserDefined(left)) {
+            throw Error(`Structural: Cannot structurally compare custom type '${left[Types.Kind]}'`);
+        }
         else {
             throw Error(`Structural: Unknown left operand '${left[Types.Kind]}'`);
         }

package/custom/custom.d.ts

@@ -0,0 +1,12 @@
+export type CustomValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean;
+/** Provides functions to create user defined types */
+export declare namespace Custom {
+    /** Clears all user defined types */
+    function Clear(): void;
+    /** Returns true if this user defined type exists */
+    function Has(kind: string): boolean;
+    /** Sets a validation function for a user defined type */
+    function Set<TSchema = unknown>(kind: string, func: CustomValidationFunction<TSchema>): void;
+    /** Gets a custom validation function for a user defined type */
+    function Get(kind: string): CustomValidationFunction<any> | undefined;
+}

package/custom/custom.js

@@ -0,0 +1,55 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/custom
+
+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.Custom = void 0;
+/** Provides functions to create user defined types */
+var Custom;
+(function (Custom) {
+    const customs = new Map();
+    /** Clears all user defined types */
+    function Clear() {
+        return customs.clear();
+    }
+    Custom.Clear = Clear;
+    /** Returns true if this user defined type exists */
+    function Has(kind) {
+        return customs.has(kind);
+    }
+    Custom.Has = Has;
+    /** Sets a validation function for a user defined type */
+    function Set(kind, func) {
+        customs.set(kind, func);
+    }
+    Custom.Set = Set;
+    /** Gets a custom validation function for a user defined type */
+    function Get(kind) {
+        return customs.get(kind);
+    }
+    Custom.Get = Get;
+})(Custom = exports.Custom || (exports.Custom = {}));

package/custom/index.d.ts

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

package/custom/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/custom
+
+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.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./custom"), exports);

package/errors/errors.d.ts

@@ -47,7 +47,8 @@ export declare enum ValueErrorType {
     Uint8Array = 44,
     Uint8ArrayMinByteLength = 45,
     Uint8ArrayMaxByteLength = 46,
-    Void = 47
+    Void = 47,
+    Custom = 48
 }
 export interface ValueError {
     type: ValueErrorType;

package/errors/errors.js

@@ -30,6 +30,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueErrors = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = void 0;
 const Types = require("../typebox");
 const index_1 = require("../format/index");
+const index_2 = require("../custom/index");
 // -------------------------------------------------------------------
 // ValueErrorType
 // -------------------------------------------------------------------
@@ -83,6 +84,7 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 45] = "Uint8ArrayMinByteLength";
     ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 46] = "Uint8ArrayMaxByteLength";
     ValueErrorType[ValueErrorType["Void"] = 47] = "Void";
+    ValueErrorType[ValueErrorType["Custom"] = 48] = "Custom";
 })(ValueErrorType = exports.ValueErrorType || (exports.ValueErrorType = {}));
 // -------------------------------------------------------------------
 // ValueErrors
@@ -365,6 +367,12 @@ var ValueErrors;
             return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected null` };
         }
     }
+    function* UserDefined(schema, references, path, value) {
+        const func = index_2.Custom.Get(schema[Types.Kind]);
+        if (!func(schema, value)) {
+            return yield { type: ValueErrorType.Custom, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` };
+        }
+    }
     function* Visit(schema, references, path, value) {
         const anyReferences = schema.$id === undefined ? references : [schema, ...references];
         const anySchema = schema;
@@ -416,7 +424,9 @@ var ValueErrors;
             case 'Void':
                 return yield* Void(anySchema, anyReferences, path, value);
             default:
-                throw new ValueErrorsUnknownTypeError(schema);
+                if (!index_2.Custom.Has(anySchema[Types.Kind]))
+                    throw new ValueErrorsUnknownTypeError(schema);
+                return yield* UserDefined(anySchema, anyReferences, path, value);
         }
     }
     function* Errors(schema, references, value) {

package/format/format.d.ts

@@ -1,12 +1,12 @@
-export declare type FormatValidationFunction = (value: string) => boolean;
-/** Provides functions to create custom string formats */
+export type FormatValidationFunction = (value: string) => boolean;
+/** Provides functions to create user defined string formats */
 export declare namespace Format {
-    /** Clears all formats */
+    /** Clears all user defined string formats */
     function Clear(): void;
-    /** Returns true if the string format exists */
+    /** Returns true if the user defined string format exists */
     function Has(format: string): boolean;
-    /** Sets a string format validation function */
+    /** Sets a validation function for a user defined string format */
     function Set(format: string, func: FormatValidationFunction): void;
-    /** Gets a string format validation function */
+    /** Gets a validation function for a user defined string format */
     function Get(format: string): FormatValidationFunction | undefined;
 }

package/format/format.js

@@ -28,26 +28,26 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Format = void 0;
-/** Provides functions to create custom string formats */
+/** Provides functions to create user defined string formats */
 var Format;
 (function (Format) {
     const formats = new Map();
-    /** Clears all formats */
+    /** Clears all user defined string formats */
     function Clear() {
         return formats.clear();
     }
     Format.Clear = Clear;
-    /** Returns true if the string format exists */
+    /** Returns true if the user defined string format exists */
     function Has(format) {
         return formats.has(format);
     }
     Format.Has = Has;
-    /** Sets a string format validation function */
+    /** Sets a validation function for a user defined string format */
     function Set(format, func) {
         formats.set(format, func);
     }
     Format.Set = Set;
-    /** Gets a string format validation function */
+    /** Gets a validation function for a user defined string format */
     function Get(format) {
         return formats.get(format);
     }

package/guard/guard.d.ts

@@ -1,5 +1,5 @@
 import * as Types from '../typebox';
-export declare class TypeGuardInvalidTypeError extends Error {
+export declare class TypeGuardUnknownTypeError extends Error {
     readonly schema: unknown;
     constructor(schema: unknown);
 }
@@ -51,6 +51,8 @@ export declare namespace TypeGuard {
     function TUnknown(schema: unknown): schema is Types.TUnknown;
     /** Returns true if the given schema is TVoid */
     function TVoid(schema: unknown): schema is Types.TVoid;
+    /** Returns true if the given schema is a registered user defined type */
+    function TUserDefined(schema: unknown): schema is Types.TSchema;
     /** Returns true if the given schema is TSchema */
     function TSchema(schema: unknown): schema is Types.TSchema;
     /** Asserts if this schema and associated references are valid. */

package/guard/guard.js

@@ -27,15 +27,16 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeGuard = exports.TypeGuardInvalidTypeError = void 0;
+exports.TypeGuard = exports.TypeGuardUnknownTypeError = void 0;
+const index_1 = require("../custom/index");
 const Types = require("../typebox");
-class TypeGuardInvalidTypeError extends Error {
+class TypeGuardUnknownTypeError extends Error {
     constructor(schema) {
-        super('TypeGuard: Invalid type');
+        super('TypeGuard: Unknown type');
         this.schema = schema;
     }
 }
-exports.TypeGuardInvalidTypeError = TypeGuardInvalidTypeError;
+exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
 /** Provides functionality to test if values are TypeBox types */
 var TypeGuard;
 (function (TypeGuard) {
@@ -393,6 +394,11 @@ var TypeGuard;
             IsOptionalString(schema.$id));
     }
     TypeGuard.TVoid = TVoid;
+    /** Returns true if the given schema is a registered user defined type */
+    function TUserDefined(schema) {
+        return IsObject(schema) && IsString(schema[Types.Kind]) && index_1.Custom.Has(schema[Types.Kind]);
+    }
+    TypeGuard.TUserDefined = TUserDefined;
     /** Returns true if the given schema is TSchema */
     function TSchema(schema) {
         return (TAny(schema) ||
@@ -417,16 +423,17 @@ var TypeGuard;
             TUnion(schema) ||
             TUint8Array(schema) ||
             TUnknown(schema) ||
-            TVoid(schema));
+            TVoid(schema) ||
+            TUserDefined(schema));
     }
     TypeGuard.TSchema = TSchema;
     /** Asserts if this schema and associated references are valid. */
     function Assert(schema, references = []) {
         if (!TSchema(schema))
-            throw new TypeGuardInvalidTypeError(schema);
+            throw new TypeGuardUnknownTypeError(schema);
         for (const schema of references) {
             if (!TSchema(schema))
-                throw new TypeGuardInvalidTypeError(schema);
+                throw new TypeGuardUnknownTypeError(schema);
         }
     }
     TypeGuard.Assert = Assert;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.8",
+  "version": "0.25.10",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -15,6 +15,7 @@
   "exports": {
     "./compiler": "./compiler/index.js",
     "./conditional": "./conditional/index.js",
+    "./custom": "./custom/index.js",
     "./errors": "./errors/index.js",
     "./format": "./format/index.js",
     "./guard": "./guard/index.js",
@@ -38,12 +39,12 @@
     "@sinclair/hammer": "^0.17.1",
     "@types/chai": "^4.3.3",
     "@types/mocha": "^9.1.1",
-    "@types/node": "^18.7.13",
-    "ajv": "^8.11.0",
+    "@types/node": "^18.11.9",
+    "ajv": "^8.11.2",
     "ajv-formats": "^2.1.1",
     "chai": "^4.3.6",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^4.8.2"
+    "typescript": "^4.9.3"
   }
 }