@sinclair/typebox 0.32.0-dev-22 → 0.32.0-dev-24

package/build/require/type/guard/type.d.ts

@@ -1,4 +1,5 @@
 import { Kind, Hint, TransformKind } from '../symbols/index';
+import { TypeBoxError } from '../error/index';
 import { TransformOptions } from '../transform/index';
 import { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index';
 import { TArray } from '../array/index';
@@ -35,7 +36,7 @@ import type { TUnsafe } from '../unsafe/index';
 import type { TVoid } from '../void/index';
 import type { TDate } from '../date/index';
 import type { TThis } from '../recursive/index';
-export declare class TypeGuardUnknownTypeError extends Error {
+export declare class TypeGuardUnknownTypeError extends TypeBoxError {
 }
 /** Returns true if this value has a Readonly symbol */
 export declare function IsReadonly<T extends TSchema>(value: T): value is TReadonly<T>;

package/build/require/type/guard/type.js

@@ -4,7 +4,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsSchema = exports.IsKind = exports.IsVoid = exports.IsUnsafe = exports.IsUnknown = exports.IsUint8Array = exports.IsUnion = exports.IsUnionLiteral = exports.IsUndefined = exports.IsTuple = exports.IsTransform = exports.IsThis = exports.IsTemplateLiteral = exports.IsSymbol = exports.IsString = exports.IsRef = exports.IsRecursive = exports.IsRecord = exports.IsPromise = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsNot = exports.IsNever = exports.IsMappedResult = exports.IsMappedKey = exports.IsLiteralValue = exports.IsLiteral = exports.IsLiteralBoolean = exports.IsLiteralNumber = exports.IsLiteralString = exports.IsKindOf = exports.IsIterator = exports.IsIntersect = exports.IsProperties = exports.IsInteger = exports.IsFunction = exports.IsDate = exports.IsConstructor = exports.IsBoolean = exports.IsBigInt = exports.IsAsyncIterator = exports.IsArray = exports.IsAny = exports.IsOptional = exports.IsReadonly = exports.TypeGuardUnknownTypeError = void 0;
 const ValueGuard = require("./value");
 const index_1 = require("../symbols/index");
-class TypeGuardUnknownTypeError extends Error {
+const index_2 = require("../error/index");
+class TypeGuardUnknownTypeError extends index_2.TypeBoxError {
 }
 exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
 const KnownTypes = [

package/build/require/type/index.d.ts

@@ -13,6 +13,7 @@ export * from './date/index';
 export * from './deref/index';
 export * from './discard/index';
 export * from './enum/index';
+export * from './error/index';
 export * from './exclude/index';
 export * from './extends/index';
 export * from './extract/index';

package/build/require/type/index.js

@@ -30,6 +30,7 @@ __exportStar(require("./date/index"), exports);
 __exportStar(require("./deref/index"), exports);
 __exportStar(require("./discard/index"), exports);
 __exportStar(require("./enum/index"), exports);
+__exportStar(require("./error/index"), exports);
 __exportStar(require("./exclude/index"), exports);
 __exportStar(require("./extends/index"), exports);
 __exportStar(require("./extract/index"), exports);

package/build/require/type/record/record.d.ts

@@ -26,7 +26,7 @@ type TFromUnionKeyLiteralNumber<K extends TLiteral<number>, T extends TSchema> =
     [_ in K['const']]: T;
 };
 type TFromUnionKeyRest<K extends TSchema[], T extends TSchema> = K extends [infer L extends TSchema, ...infer R extends TSchema[]] ? (L extends TUnion<infer S> ? TFromUnionKeyRest<S, T> & TFromUnionKeyRest<R, T> : L extends TLiteral<string> ? TFromUnionKeyLiteralString<L, T> & TFromUnionKeyRest<R, T> : L extends TLiteral<number> ? TFromUnionKeyLiteralNumber<L, T> & TFromUnionKeyRest<R, T> : {}) : {};
-type TFromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties = TFromUnionKeyRest<K, T>> = (Ensure<TObject<P>>);
+type TFromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties = TFromUnionKeyRest<K, T>> = (Ensure<TObject<Evaluate<P>>>);
 type TFromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObject<{
     [_ in Assert<K, PropertyKey>]: T;
 }>>);

package/build/require/type/template-literal/finite.d.ts

@@ -1,3 +1,4 @@
+import { TypeBoxError } from '../error/index';
 import type { TTemplateLiteral, TTemplateLiteralKind } from './index';
 import type { TUnion } from '../union/index';
 import type { TString } from '../string/index';
@@ -7,7 +8,7 @@ import type { TInteger } from '../integer/index';
 import type { TBigInt } from '../bigint/index';
 import type { TLiteral } from '../literal/index';
 import type { Expression } from './parse';
-export declare class TemplateLiteralFiniteError extends Error {
+export declare class TemplateLiteralFiniteError extends TypeBoxError {
 }
 type TFromTemplateLiteralKind<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<U> : T extends TString ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TBoolean ? true : T extends TLiteral ? true : false;
 type TFromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? TFromTemplateLiteralKind<L> extends false ? false : TFromTemplateLiteralKinds<R> : true;

package/build/require/type/template-literal/finite.js

@@ -3,10 +3,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsTemplateLiteralFinite = exports.IsTemplateLiteralExpressionFinite = exports.TemplateLiteralFiniteError = void 0;
 const parse_1 = require("./parse");
+const index_1 = require("../error/index");
 // ------------------------------------------------------------------
 // TemplateLiteralFiniteError
 // ------------------------------------------------------------------
-class TemplateLiteralFiniteError extends Error {
+class TemplateLiteralFiniteError extends index_1.TypeBoxError {
 }
 exports.TemplateLiteralFiniteError = TemplateLiteralFiniteError;
 // ------------------------------------------------------------------

package/build/require/type/template-literal/generate.d.ts

@@ -1,17 +1,18 @@
 import { TIsTemplateLiteralFinite } from './finite';
+import { TypeBoxError } from '../error/index';
 import type { Assert } from '../helpers/index';
 import type { TBoolean } from '../boolean/index';
 import type { TTemplateLiteral, TTemplateLiteralKind } from './index';
 import type { TLiteral, TLiteralValue } from '../literal/index';
 import type { Expression } from './parse';
 import type { TUnion } from '../union/index';
-export declare class TemplateLiteralGenerateError extends Error {
+export declare class TemplateLiteralGenerateError extends TypeBoxError {
 }
 type TStringReduceUnary<L extends string, R extends string[], Acc extends string[] = []> = R extends [infer A extends string, ...infer B extends string[]] ? TStringReduceUnary<L, B, [...Acc, `${L}${A}`]> : Acc;
 type TStringReduceBinary<L extends string[], R extends string[], Acc extends string[] = []> = L extends [infer A extends string, ...infer B extends string[]] ? TStringReduceBinary<B, R, [...Acc, ...TStringReduceUnary<A, R>]> : Acc;
 type TStringReduceMany<T extends string[][]> = T extends [infer L extends string[], infer R extends string[], ...infer Rest extends string[][]] ? TStringReduceMany<[TStringReduceBinary<L, R>, ...Rest]> : T;
 type TStringReduce<T extends string[][], O = TStringReduceMany<T>> = 0 extends keyof O ? Assert<O[0], string[]> : [];
-type TFromTemplateLiteralUnionKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [L['const'], ...TFromTemplateLiteralUnionKinds<R>] : [];
+type TFromTemplateLiteralUnionKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [`${L['const']}`, ...TFromTemplateLiteralUnionKinds<R>] : [];
 type TFromTemplateLiteralKinds<T extends TTemplateLiteralKind[], Acc extends TLiteralValue[][] = []> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? (L extends TLiteral<infer S extends TLiteralValue> ? TFromTemplateLiteralKinds<R, [...Acc, [S]]> : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<R, [...Acc, TFromTemplateLiteralUnionKinds<S>]> : L extends TBoolean ? TFromTemplateLiteralKinds<R, [...Acc, ['true', 'false']]> : Acc) : Acc;
 export declare function TemplateLiteralExpressionGenerate(expression: Expression): IterableIterator<string>;
 export type TTemplateLiteralGenerate<T extends TTemplateLiteral, F = TIsTemplateLiteralFinite<T>> = F extends true ? (T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<S> extends infer R extends string[][] ? TStringReduce<R> : [] : []) : [];

package/build/require/type/template-literal/generate.js

@@ -4,10 +4,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralGenerate = exports.TemplateLiteralExpressionGenerate = exports.TemplateLiteralGenerateError = void 0;
 const finite_1 = require("./finite");
 const parse_1 = require("./parse");
+const index_1 = require("../error/index");
 // ------------------------------------------------------------------
 // TemplateLiteralGenerateError
 // ------------------------------------------------------------------
-class TemplateLiteralGenerateError extends Error {
+class TemplateLiteralGenerateError extends index_1.TypeBoxError {
 }
 exports.TemplateLiteralGenerateError = TemplateLiteralGenerateError;
 // ------------------------------------------------------------------

package/build/require/type/template-literal/parse.d.ts

@@ -1,4 +1,5 @@
-export declare class TemplateLiteralParserError extends Error {
+import { TypeBoxError } from '../error/index';
+export declare class TemplateLiteralParserError extends TypeBoxError {
 }
 export type Expression = ExpressionAnd | ExpressionOr | ExpressionConst;
 export type ExpressionConst = {

package/build/require/type/template-literal/parse.js

@@ -1,11 +1,12 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.TemplateLiteralParserError = void 0;
+
+const index_1 = require("../error/index");
 // ------------------------------------------------------------------
 // TemplateLiteralParserError
 // ------------------------------------------------------------------
-class TemplateLiteralParserError extends Error {
+class TemplateLiteralParserError extends index_1.TypeBoxError {
 }
 exports.TemplateLiteralParserError = TemplateLiteralParserError;
 // prettier-ignore

package/build/require/type/template-literal/pattern.d.ts

@@ -1,4 +1,5 @@
 import type { TTemplateLiteralKind } from './index';
-export declare class TemplateLiteralPatternError extends Error {
+import { TypeBoxError } from '../error/index';
+export declare class TemplateLiteralPatternError extends TypeBoxError {
 }
 export declare function TemplateLiteralPattern(kinds: TTemplateLiteralKind[]): string;

package/build/require/type/template-literal/pattern.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralPattern = exports.TemplateLiteralPatternError = void 0;
 const index_1 = require("../patterns/index");
 const index_2 = require("../symbols/index");
+const index_3 = require("../error/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -12,7 +13,7 @@ const type_1 = require("../guard/type");
 // ------------------------------------------------------------------
 // TemplateLiteralPatternError
 // ------------------------------------------------------------------
-class TemplateLiteralPatternError extends Error {
+class TemplateLiteralPatternError extends index_3.TypeBoxError {
 }
 exports.TemplateLiteralPatternError = TemplateLiteralPatternError;
 // ------------------------------------------------------------------

package/build/require/value/cast/cast.d.ts

@@ -1,19 +1,20 @@
+import { TypeBoxError } from '../../type/error/index';
 import type { TSchema } from '../../type/schema/index';
 import type { Static } from '../../type/static/index';
-export declare class ValueCastArrayUniqueItemsTypeError extends Error {
+export declare class ValueCastArrayUniqueItemsTypeError extends TypeBoxError {
     readonly schema: TSchema;
     readonly value: unknown;
     constructor(schema: TSchema, value: unknown);
 }
-export declare class ValueCastNeverTypeError extends Error {
+export declare class ValueCastNeverTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCastRecursiveTypeError extends Error {
+export declare class ValueCastRecursiveTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCastUnknownTypeError extends Error {
+export declare class ValueCastUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }

package/build/require/value/cast/cast.js

@@ -3,15 +3,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cast = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = void 0;
 const index_1 = require("../guard/index");
-const index_2 = require("../../type/symbols/index");
-const index_3 = require("../create/index");
-const index_4 = require("../check/index");
-const index_5 = require("../clone/index");
-const index_6 = require("../deref/index");
+const index_2 = require("../../type/error/index");
+const index_3 = require("../../type/symbols/index");
+const index_4 = require("../create/index");
+const index_5 = require("../check/index");
+const index_6 = require("../clone/index");
+const index_7 = require("../deref/index");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueCastArrayUniqueItemsTypeError extends Error {
+class ValueCastArrayUniqueItemsTypeError extends index_2.TypeBoxError {
     constructor(schema, value) {
         super('Array cast produced invalid data due to uniqueItems constraint');
         this.schema = schema;
@@ -19,21 +20,21 @@ class ValueCastArrayUniqueItemsTypeError extends Error {
     }
 }
 exports.ValueCastArrayUniqueItemsTypeError = ValueCastArrayUniqueItemsTypeError;
-class ValueCastNeverTypeError extends Error {
+class ValueCastNeverTypeError extends index_2.TypeBoxError {
     constructor(schema) {
         super('Never types cannot be cast');
         this.schema = schema;
     }
 }
 exports.ValueCastNeverTypeError = ValueCastNeverTypeError;
-class ValueCastRecursiveTypeError extends Error {
+class ValueCastRecursiveTypeError extends index_2.TypeBoxError {
     constructor(schema) {
         super('Cannot cast recursive schemas');
         this.schema = schema;
     }
 }
 exports.ValueCastRecursiveTypeError = ValueCastRecursiveTypeError;
-class ValueCastUnknownTypeError extends Error {
+class ValueCastUnknownTypeError extends index_2.TypeBoxError {
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
@@ -49,20 +50,20 @@ exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
 // used as union discriminator fields.
 // ------------------------------------------------------------------
 function ScoreUnion(schema, references, value) {
-    if (schema[index_2.Kind] === 'Object' && typeof value === 'object' && !(0, index_1.IsNull)(value)) {
+    if (schema[index_3.Kind] === 'Object' && typeof value === 'object' && !(0, index_1.IsNull)(value)) {
         const object = schema;
         const keys = Object.getOwnPropertyNames(value);
         const entries = Object.entries(object.properties);
         const [point, max] = [1 / entries.length, entries.length];
         return entries.reduce((acc, [key, schema]) => {
-            const literal = schema[index_2.Kind] === 'Literal' && schema.const === value[key] ? max : 0;
-            const checks = (0, index_4.Check)(schema, references, value[key]) ? point : 0;
+            const literal = schema[index_3.Kind] === 'Literal' && schema.const === value[key] ? max : 0;
+            const checks = (0, index_5.Check)(schema, references, value[key]) ? point : 0;
             const exists = keys.includes(key) ? point : 0;
             return acc + (literal + checks + exists);
         }, 0);
     }
     else {
-        return (0, index_4.Check)(schema, references, value) ? 1 : 0;
+        return (0, index_5.Check)(schema, references, value) ? 1 : 0;
     }
 }
 function SelectUnion(union, references, value) {
@@ -89,31 +90,31 @@ function CastUnion(union, references, value) {
 // Default
 // ------------------------------------------------------------------
 function DefaultClone(schema, references, value) {
-    return (0, index_4.Check)(schema, references, value) ? (0, index_5.Clone)(value) : (0, index_3.Create)(schema, references);
+    return (0, index_5.Check)(schema, references, value) ? (0, index_6.Clone)(value) : (0, index_4.Create)(schema, references);
 }
 function Default(schema, references, value) {
-    return (0, index_4.Check)(schema, references, value) ? value : (0, index_3.Create)(schema, references);
+    return (0, index_5.Check)(schema, references, value) ? value : (0, index_4.Create)(schema, references);
 }
 // ------------------------------------------------------------------
 // Cast
 // ------------------------------------------------------------------
 function FromArray(schema, references, value) {
-    if ((0, index_4.Check)(schema, references, value))
-        return (0, index_5.Clone)(value);
-    const created = (0, index_1.IsArray)(value) ? (0, index_5.Clone)(value) : (0, index_3.Create)(schema, references);
+    if ((0, index_5.Check)(schema, references, value))
+        return (0, index_6.Clone)(value);
+    const created = (0, index_1.IsArray)(value) ? (0, index_6.Clone)(value) : (0, index_4.Create)(schema, references);
     const minimum = (0, index_1.IsNumber)(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created;
     const maximum = (0, index_1.IsNumber)(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
     const casted = maximum.map((value) => Visit(schema.items, references, value));
     if (schema.uniqueItems !== true)
         return casted;
     const unique = [...new Set(casted)];
-    if (!(0, index_4.Check)(schema, references, unique))
+    if (!(0, index_5.Check)(schema, references, unique))
         throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
     return unique;
 }
 function FromConstructor(schema, references, value) {
-    if ((0, index_4.Check)(schema, references, value))
-        return (0, index_3.Create)(schema, references);
+    if ((0, index_5.Check)(schema, references, value))
+        return (0, index_4.Create)(schema, references);
     const required = new Set(schema.returns.required || []);
     const result = function () { };
     for (const [key, property] of Object.entries(schema.returns.properties)) {
@@ -124,18 +125,18 @@ function FromConstructor(schema, references, value) {
     return result;
 }
 function FromIntersect(schema, references, value) {
-    const created = (0, index_3.Create)(schema, references);
+    const created = (0, index_4.Create)(schema, references);
     const mapped = (0, index_1.IsPlainObject)(created) && (0, index_1.IsPlainObject)(value) ? { ...created, ...value } : value;
-    return (0, index_4.Check)(schema, references, mapped) ? mapped : (0, index_3.Create)(schema, references);
+    return (0, index_5.Check)(schema, references, mapped) ? mapped : (0, index_4.Create)(schema, references);
 }
 function FromNever(schema, references, value) {
     throw new ValueCastNeverTypeError(schema);
 }
 function FromObject(schema, references, value) {
-    if ((0, index_4.Check)(schema, references, value))
+    if ((0, index_5.Check)(schema, references, value))
         return value;
     if (value === null || typeof value !== 'object')
-        return (0, index_3.Create)(schema, references);
+        return (0, index_4.Create)(schema, references);
     const required = new Set(schema.required || []);
     const result = {};
     for (const [key, property] of Object.entries(schema.properties)) {
@@ -155,10 +156,10 @@ function FromObject(schema, references, value) {
     return result;
 }
 function FromRecord(schema, references, value) {
-    if ((0, index_4.Check)(schema, references, value))
-        return (0, index_5.Clone)(value);
+    if ((0, index_5.Check)(schema, references, value))
+        return (0, index_6.Clone)(value);
     if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date)
-        return (0, index_3.Create)(schema, references);
+        return (0, index_4.Create)(schema, references);
     const subschemaPropertyName = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const subschema = schema.patternProperties[subschemaPropertyName];
     const result = {};
@@ -168,27 +169,27 @@ function FromRecord(schema, references, value) {
     return result;
 }
 function FromRef(schema, references, value) {
-    return Visit((0, index_6.Deref)(schema, references), references, value);
+    return Visit((0, index_7.Deref)(schema, references), references, value);
 }
 function FromThis(schema, references, value) {
-    return Visit((0, index_6.Deref)(schema, references), references, value);
+    return Visit((0, index_7.Deref)(schema, references), references, value);
 }
 function FromTuple(schema, references, value) {
-    if ((0, index_4.Check)(schema, references, value))
-        return (0, index_5.Clone)(value);
+    if ((0, index_5.Check)(schema, references, value))
+        return (0, index_6.Clone)(value);
     if (!(0, index_1.IsArray)(value))
-        return (0, index_3.Create)(schema, references);
+        return (0, index_4.Create)(schema, references);
     if (schema.items === undefined)
         return [];
     return schema.items.map((schema, index) => Visit(schema, references, value[index]));
 }
 function FromUnion(schema, references, value) {
-    return (0, index_4.Check)(schema, references, value) ? (0, index_5.Clone)(value) : CastUnion(schema, references, value);
+    return (0, index_5.Check)(schema, references, value) ? (0, index_6.Clone)(value) : CastUnion(schema, references, value);
 }
 function Visit(schema, references, value) {
     const references_ = (0, index_1.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema[index_2.Kind]) {
+    switch (schema[index_3.Kind]) {
         // --------------------------------------------------------------
         // Structural
         // --------------------------------------------------------------

package/build/require/value/check/check.d.ts

@@ -1,6 +1,7 @@
+import { TypeBoxError } from '../../type/error/index';
 import type { TSchema } from '../../type/schema/index';
 import type { Static } from '../../type/static/index';
-export declare class ValueCheckUnknownTypeError extends Error {
+export declare class ValueCheckUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }

package/build/require/value/check/check.js

@@ -9,12 +9,13 @@ const index_4 = require("../../type/symbols/index");
 const index_5 = require("../../type/keyof/index");
 const index_6 = require("../../type/extends/index");
 const index_7 = require("../../type/registry/index");
-const index_8 = require("../../type/never/index");
+const index_8 = require("../../type/error/index");
+const index_9 = require("../../type/never/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-const index_9 = require("../guard/index");
+const index_10 = require("../guard/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -22,7 +23,7 @@ const type_1 = require("../../type/guard/type");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueCheckUnknownTypeError extends Error {
+class ValueCheckUnknownTypeError extends index_8.TypeBoxError {
     constructor(schema) {
         super(`Unknown type`);
         this.schema = schema;
@@ -48,7 +49,7 @@ function FromAny(schema, references, value) {
     return true;
 }
 function FromArray(schema, references, value) {
-    if (!(0, index_9.IsArray)(value))
+    if (!(0, index_10.IsArray)(value))
         return false;
     if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
         return false;
@@ -72,27 +73,27 @@ function FromArray(schema, references, value) {
         return false;
     }
     // contains
-    if (!(IsDefined(schema.contains) || (0, index_9.IsNumber)(schema.minContains) || (0, index_9.IsNumber)(schema.maxContains))) {
+    if (!(IsDefined(schema.contains) || (0, index_10.IsNumber)(schema.minContains) || (0, index_10.IsNumber)(schema.maxContains))) {
         return true; // exit
     }
-    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_8.Never)();
+    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_9.Never)();
     const containsCount = value.reduce((acc, value) => (Visit(containsSchema, references, value) ? acc + 1 : acc), 0);
     if (containsCount === 0) {
         return false;
     }
-    if ((0, index_9.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
+    if ((0, index_10.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
         return false;
     }
-    if ((0, index_9.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
+    if ((0, index_10.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
         return false;
     }
     return true;
 }
 function FromAsyncIterator(schema, references, value) {
-    return (0, index_9.IsAsyncIterator)(value);
+    return (0, index_10.IsAsyncIterator)(value);
 }
 function FromBigInt(schema, references, value) {
-    if (!(0, index_9.IsBigInt)(value))
+    if (!(0, index_10.IsBigInt)(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         return false;
@@ -112,13 +113,13 @@ function FromBigInt(schema, references, value) {
     return true;
 }
 function FromBoolean(schema, references, value) {
-    return (0, index_9.IsBoolean)(value);
+    return (0, index_10.IsBoolean)(value);
 }
 function FromConstructor(schema, references, value) {
     return Visit(schema.returns, references, value.prototype);
 }
 function FromDate(schema, references, value) {
-    if (!(0, index_9.IsDate)(value))
+    if (!(0, index_10.IsDate)(value))
         return false;
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
         return false;
@@ -138,10 +139,10 @@ function FromDate(schema, references, value) {
     return true;
 }
 function FromFunction(schema, references, value) {
-    return (0, index_9.IsFunction)(value);
+    return (0, index_10.IsFunction)(value);
 }
 function FromInteger(schema, references, value) {
-    if (!(0, index_9.IsInteger)(value)) {
+    if (!(0, index_10.IsInteger)(value)) {
         return false;
     }
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -178,7 +179,7 @@ function FromIntersect(schema, references, value) {
     }
 }
 function FromIterator(schema, references, value) {
-    return (0, index_9.IsIterator)(value);
+    return (0, index_10.IsIterator)(value);
 }
 function FromLiteral(schema, references, value) {
     return value === schema.const;
@@ -190,7 +191,7 @@ function FromNot(schema, references, value) {
     return !Visit(schema.not, references, value);
 }
 function FromNull(schema, references, value) {
-    return (0, index_9.IsNull)(value);
+    return (0, index_10.IsNull)(value);
 }
 function FromNumber(schema, references, value) {
     if (!index_1.TypeSystemPolicy.IsNumberLike(value))
@@ -257,7 +258,7 @@ function FromObject(schema, references, value) {
     }
 }
 function FromPromise(schema, references, value) {
-    return (0, index_9.IsPromise)(value);
+    return (0, index_10.IsPromise)(value);
 }
 function FromRecord(schema, references, value) {
     if (!index_1.TypeSystemPolicy.IsRecordLike(value)) {
@@ -290,7 +291,7 @@ function FromRef(schema, references, value) {
     return Visit((0, index_2.Deref)(schema, references), references, value);
 }
 function FromString(schema, references, value) {
-    if (!(0, index_9.IsString)(value)) {
+    if (!(0, index_10.IsString)(value)) {
         return false;
     }
     if (IsDefined(schema.minLength)) {
@@ -315,16 +316,16 @@ function FromString(schema, references, value) {
     return true;
 }
 function FromSymbol(schema, references, value) {
-    return (0, index_9.IsSymbol)(value);
+    return (0, index_10.IsSymbol)(value);
 }
 function FromTemplateLiteral(schema, references, value) {
-    return (0, index_9.IsString)(value) && new RegExp(schema.pattern).test(value);
+    return (0, index_10.IsString)(value) && new RegExp(schema.pattern).test(value);
 }
 function FromThis(schema, references, value) {
     return Visit((0, index_2.Deref)(schema, references), references, value);
 }
 function FromTuple(schema, references, value) {
-    if (!(0, index_9.IsArray)(value)) {
+    if (!(0, index_10.IsArray)(value)) {
         return false;
     }
     if (schema.items === undefined && !(value.length === 0)) {
@@ -343,13 +344,13 @@ function FromTuple(schema, references, value) {
     return true;
 }
 function FromUndefined(schema, references, value) {
-    return (0, index_9.IsUndefined)(value);
+    return (0, index_10.IsUndefined)(value);
 }
 function FromUnion(schema, references, value) {
     return schema.anyOf.some((inner) => Visit(inner, references, value));
 }
 function FromUint8Array(schema, references, value) {
-    if (!(0, index_9.IsUint8Array)(value)) {
+    if (!(0, index_10.IsUint8Array)(value)) {
         return false;
     }
     if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {

package/build/require/value/convert/convert.d.ts

@@ -1,5 +1,6 @@
+import { TypeBoxError } from '../../type/error/index';
 import type { TSchema } from '../../type/schema/index';
-export declare class ValueConvertUnknownTypeError extends Error {
+export declare class ValueConvertUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }