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

package/build/import/compiler/compiler.d.mts

@@ -1,4 +1,5 @@
 import { ValueErrorIterator } from '../errors/index.mjs';
+import { TypeBoxError } from '../type/error/index.mjs';
 import type { TSchema } from '../type/schema/index.mjs';
 import type { Static, StaticDecode, StaticEncode } from '../type/static/index.mjs';
 export type CheckFunction = (value: unknown) => boolean;
@@ -20,11 +21,11 @@ export declare class TypeCheck<T extends TSchema> {
     /** Encodes a value or throws if error */
     Encode(value: unknown): StaticEncode<T>;
 }
-export declare class TypeCompilerUnknownTypeError extends Error {
+export declare class TypeCompilerUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class TypeCompilerTypeGuardError extends Error {
+export declare class TypeCompilerTypeGuardError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }

package/build/import/compiler/compiler.mjs

@@ -1,6 +1,7 @@
 import { TransformEncode, TransformDecode, HasTransform, TransformDecodeCheckError, TransformEncodeCheckError } from '../value/transform/index.mjs';
 import { Errors } from '../errors/index.mjs';
 import { TypeSystemPolicy } from '../system/index.mjs';
+import { TypeBoxError } from '../type/error/index.mjs';
 import { Deref } from '../value/deref/index.mjs';
 import { Hash } from '../value/hash/index.mjs';
 import { Kind } from '../type/symbols/index.mjs';
@@ -142,14 +143,14 @@ var LiteralString;
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class TypeCompilerUnknownTypeError extends Error {
+export class TypeCompilerUnknownTypeError extends TypeBoxError {
     schema;
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
     }
 }
-export class TypeCompilerTypeGuardError extends Error {
+export class TypeCompilerTypeGuardError extends TypeBoxError {
     schema;
     constructor(schema) {
         super('Preflight validation check failed to guard for the given schema');

package/build/import/errors/errors.d.mts

@@ -1,3 +1,4 @@
+import { TypeBoxError } from '../type/error/index.mjs';
 import type { TSchema } from '../type/schema/index.mjs';
 export declare enum ValueErrorType {
     ArrayContains = 0,
@@ -71,7 +72,7 @@ export interface ValueError {
     value: unknown;
     message: string;
 }
-export declare class ValueErrorsUnknownTypeError extends Error {
+export declare class ValueErrorsUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }

package/build/import/errors/errors.mjs

@@ -3,6 +3,7 @@ import { KeyOfPattern } from '../type/keyof/index.mjs';
 import { TypeRegistry, FormatRegistry } from '../type/registry/index.mjs';
 import { ExtendsUndefinedCheck } from '../type/extends/extends-undefined.mjs';
 import { GetErrorFunction } from './function.mjs';
+import { TypeBoxError } from '../type/error/index.mjs';
 import { Deref } from '../value/deref/index.mjs';
 import { Hash } from '../value/hash/index.mjs';
 import { Kind } from '../type/symbols/index.mjs';
@@ -84,7 +85,7 @@ export var ValueErrorType;
 // ------------------------------------------------------------------
 // ValueErrors
 // ------------------------------------------------------------------
-export class ValueErrorsUnknownTypeError extends Error {
+export class ValueErrorsUnknownTypeError extends TypeBoxError {
     schema;
     constructor(schema) {
         super('Unknown type');

package/build/import/index.d.mts

@@ -3,6 +3,7 @@ export { PatternBoolean, PatternBooleanExact, PatternNumber, PatternNumberExact,
 export { TypeRegistry, FormatRegistry } from './type/registry/index.mjs';
 export { TypeGuard, ValueGuard } from './type/guard/index.mjs';
 export { CloneType, CloneRest } from './type/clone/type.mjs';
+export { TypeBoxError } from './type/error/index.mjs';
 export { Any, type TAny } from './type/any/index.mjs';
 export { Array, type TArray, type ArrayOptions } from './type/array/index.mjs';
 export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index.mjs';

package/build/import/index.mjs

@@ -6,6 +6,7 @@ export { PatternBoolean, PatternBooleanExact, PatternNumber, PatternNumberExact,
 export { TypeRegistry, FormatRegistry } from './type/registry/index.mjs';
 export { TypeGuard, ValueGuard } from './type/guard/index.mjs';
 export { CloneType, CloneRest } from './type/clone/type.mjs';
+export { TypeBoxError } from './type/error/index.mjs';
 // ------------------------------------------------------------------
 // Type
 // ------------------------------------------------------------------

package/build/import/system/system.d.mts

@@ -1,7 +1,8 @@
-export declare class TypeSystemDuplicateTypeKind extends Error {
+import { TypeBoxError } from '../type/error/index.mjs';
+export declare class TypeSystemDuplicateTypeKind extends TypeBoxError {
     constructor(kind: string);
 }
-export declare class TypeSystemDuplicateFormat extends Error {
+export declare class TypeSystemDuplicateFormat extends TypeBoxError {
     constructor(kind: string);
 }
 /** Creates user defined types and formats and provides overrides for value checking behaviours */

package/build/import/system/system.mjs

@@ -1,15 +1,16 @@
 import { TypeRegistry, FormatRegistry } from '../type/registry/index.mjs';
 import { Unsafe } from '../type/unsafe/index.mjs';
 import { Kind } from '../type/symbols/index.mjs';
+import { TypeBoxError } from '../type/error/index.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class TypeSystemDuplicateTypeKind extends Error {
+export class TypeSystemDuplicateTypeKind extends TypeBoxError {
     constructor(kind) {
         super(`Duplicate type kind '${kind}' detected`);
     }
 }
-export class TypeSystemDuplicateFormat extends Error {
+export class TypeSystemDuplicateFormat extends TypeBoxError {
     constructor(kind) {
         super(`Duplicate string format '${kind}' detected`);
     }

package/build/import/type/error/error.d.mts

@@ -0,0 +1,4 @@
+/** The base Error type thrown for all TypeBox exceptions  */
+export declare class TypeBoxError extends Error {
+    constructor(message: string);
+}

package/build/import/type/error/error.mjs

@@ -0,0 +1,6 @@
+/** The base Error type thrown for all TypeBox exceptions  */
+export class TypeBoxError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}

package/build/import/type/error/index.d.mts

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

package/build/import/type/error/index.mjs

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

package/build/import/type/extends/extends-check.d.mts

@@ -1,5 +1,6 @@
 import { type TSchema } from '../schema/index.mjs';
-export declare class ExtendsResolverError extends Error {
+import { TypeBoxError } from '../error/index.mjs';
+export declare class ExtendsResolverError extends TypeBoxError {
 }
 export declare enum ExtendsResult {
     Union = 0,

package/build/import/type/extends/extends-check.mjs

@@ -6,8 +6,9 @@ import { Unknown } from '../unknown/index.mjs';
 import { TemplateLiteralToUnion } from '../template-literal/index.mjs';
 import { PatternNumberExact, PatternStringExact } from '../patterns/index.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
+import { TypeBoxError } from '../error/index.mjs';
 import { TypeGuard, ValueGuard } from '../guard/index.mjs';
-export class ExtendsResolverError extends Error {
+export class ExtendsResolverError extends TypeBoxError {
 }
 export var ExtendsResult;
 (function (ExtendsResult) {

package/build/import/type/guard/type.d.mts

@@ -1,4 +1,5 @@
 import { Kind, Hint, TransformKind } from '../symbols/index.mjs';
+import { TypeBoxError } from '../error/index.mjs';
 import { TransformOptions } from '../transform/index.mjs';
 import { TTemplateLiteral, TTemplateLiteralKind } from '../template-literal/index.mjs';
 import { TArray } from '../array/index.mjs';
@@ -35,7 +36,7 @@ import type { TUnsafe } from '../unsafe/index.mjs';
 import type { TVoid } from '../void/index.mjs';
 import type { TDate } from '../date/index.mjs';
 import type { TThis } from '../recursive/index.mjs';
-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/import/type/guard/type.mjs

@@ -1,6 +1,7 @@
 import * as ValueGuard from './value.mjs';
 import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index.mjs';
-export class TypeGuardUnknownTypeError extends Error {
+import { TypeBoxError } from '../error/index.mjs';
+export class TypeGuardUnknownTypeError extends TypeBoxError {
 }
 const KnownTypes = [
     'Any',

package/build/import/type/index.d.mts

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

package/build/import/type/index.mjs

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

package/build/import/type/record/record.d.mts

@@ -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/import/type/template-literal/finite.d.mts

@@ -1,3 +1,4 @@
+import { TypeBoxError } from '../error/index.mjs';
 import type { TTemplateLiteral, TTemplateLiteralKind } from './index.mjs';
 import type { TUnion } from '../union/index.mjs';
 import type { TString } from '../string/index.mjs';
@@ -7,7 +8,7 @@ import type { TInteger } from '../integer/index.mjs';
 import type { TBigInt } from '../bigint/index.mjs';
 import type { TLiteral } from '../literal/index.mjs';
 import type { Expression } from './parse.mjs';
-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/import/type/template-literal/finite.mjs

@@ -1,8 +1,9 @@
 import { TemplateLiteralParseExact } from './parse.mjs';
+import { TypeBoxError } from '../error/index.mjs';
 // ------------------------------------------------------------------
 // TemplateLiteralFiniteError
 // ------------------------------------------------------------------
-export class TemplateLiteralFiniteError extends Error {
+export class TemplateLiteralFiniteError extends TypeBoxError {
 }
 // ------------------------------------------------------------------
 // IsTemplateLiteralFiniteCheck

package/build/import/type/template-literal/generate.d.mts

@@ -1,17 +1,18 @@
 import { TIsTemplateLiteralFinite } from './finite.mjs';
+import { TypeBoxError } from '../error/index.mjs';
 import type { Assert } from '../helpers/index.mjs';
 import type { TBoolean } from '../boolean/index.mjs';
 import type { TTemplateLiteral, TTemplateLiteralKind } from './index.mjs';
 import type { TLiteral, TLiteralValue } from '../literal/index.mjs';
 import type { Expression } from './parse.mjs';
 import type { TUnion } from '../union/index.mjs';
-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/import/type/template-literal/generate.mjs

@@ -1,9 +1,10 @@
 import { IsTemplateLiteralExpressionFinite } from './finite.mjs';
 import { TemplateLiteralParseExact } from './parse.mjs';
+import { TypeBoxError } from '../error/index.mjs';
 // ------------------------------------------------------------------
 // TemplateLiteralGenerateError
 // ------------------------------------------------------------------
-export class TemplateLiteralGenerateError extends Error {
+export class TemplateLiteralGenerateError extends TypeBoxError {
 }
 // ------------------------------------------------------------------
 // TemplateLiteralExpressionGenerate

package/build/import/type/template-literal/parse.d.mts

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

package/build/import/type/template-literal/parse.mjs

@@ -1,7 +1,8 @@
+import { TypeBoxError } from '../error/index.mjs';
 // ------------------------------------------------------------------
 // TemplateLiteralParserError
 // ------------------------------------------------------------------
-export class TemplateLiteralParserError extends Error {
+export class TemplateLiteralParserError extends TypeBoxError {
 }
 // prettier-ignore
 function IsNonEscaped(pattern, index, char) {

package/build/import/type/template-literal/pattern.d.mts

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

package/build/import/type/template-literal/pattern.mjs

@@ -1,5 +1,6 @@
 import { PatternNumber, PatternString, PatternBoolean } from '../patterns/index.mjs';
 import { Kind } from '../symbols/index.mjs';
+import { TypeBoxError } from '../error/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -8,7 +9,7 @@ import { IsTemplateLiteral, IsUnion, IsNumber, IsInteger, IsBigInt, IsString, Is
 // ------------------------------------------------------------------
 // TemplateLiteralPatternError
 // ------------------------------------------------------------------
-export class TemplateLiteralPatternError extends Error {
+export class TemplateLiteralPatternError extends TypeBoxError {
 }
 // ------------------------------------------------------------------
 // TemplateLiteralPattern

package/build/import/value/cast/cast.d.mts

@@ -1,19 +1,20 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
 import type { TSchema } from '../../type/schema/index.mjs';
 import type { Static } from '../../type/static/index.mjs';
-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/import/value/cast/cast.mjs

@@ -1,4 +1,5 @@
 import { IsPlainObject, IsArray, IsString, IsNumber, IsNull } from '../guard/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 import { Create } from '../create/index.mjs';
 import { Check } from '../check/index.mjs';
@@ -7,7 +8,7 @@ import { Deref } from '../deref/index.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueCastArrayUniqueItemsTypeError extends Error {
+export class ValueCastArrayUniqueItemsTypeError extends TypeBoxError {
     schema;
     value;
     constructor(schema, value) {
@@ -16,21 +17,21 @@ export class ValueCastArrayUniqueItemsTypeError extends Error {
         this.value = value;
     }
 }
-export class ValueCastNeverTypeError extends Error {
+export class ValueCastNeverTypeError extends TypeBoxError {
     schema;
     constructor(schema) {
         super('Never types cannot be cast');
         this.schema = schema;
     }
 }
-export class ValueCastRecursiveTypeError extends Error {
+export class ValueCastRecursiveTypeError extends TypeBoxError {
     schema;
     constructor(schema) {
         super('Cannot cast recursive schemas');
         this.schema = schema;
     }
 }
-export class ValueCastUnknownTypeError extends Error {
+export class ValueCastUnknownTypeError extends TypeBoxError {
     schema;
     constructor(schema) {
         super('Unknown type');

package/build/import/value/check/check.d.mts

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

package/build/import/value/check/check.mjs

@@ -5,6 +5,7 @@ import { Kind } from '../../type/symbols/index.mjs';
 import { KeyOfPattern } from '../../type/keyof/index.mjs';
 import { ExtendsUndefinedCheck } from '../../type/extends/index.mjs';
 import { TypeRegistry, FormatRegistry } from '../../type/registry/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
 import { Never } from '../../type/never/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
@@ -18,7 +19,7 @@ import { IsSchema } from '../../type/guard/type.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueCheckUnknownTypeError extends Error {
+export class ValueCheckUnknownTypeError extends TypeBoxError {
     schema;
     constructor(schema) {
         super(`Unknown type`);

package/build/import/value/convert/convert.d.mts

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

package/build/import/value/convert/convert.mjs

@@ -1,6 +1,7 @@
 import { Clone } from '../clone/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Deref } from '../deref/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
 import { IsObject as IsObjectType } from '../../type/guard/type.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 import { Composite } from '../../type/composite/index.mjs';
@@ -12,7 +13,7 @@ import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean,
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueConvertUnknownTypeError extends Error {
+export class ValueConvertUnknownTypeError extends TypeBoxError {
     schema;
     constructor(schema) {
         super('Unknown type');

package/build/import/value/create/create.d.mts

@@ -1,26 +1,27 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
 import type { TSchema } from '../../type/schema/index.mjs';
 import type { Static } from '../../type/static/index.mjs';
-export declare class ValueCreateUnknownTypeError extends Error {
+export declare class ValueCreateUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCreateNeverTypeError extends Error {
+export declare class ValueCreateNeverTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCreateNotTypeError extends Error {
+export declare class ValueCreateNotTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCreateIntersectTypeError extends Error {
+export declare class ValueCreateIntersectTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCreateTempateLiteralTypeError extends Error {
+export declare class ValueCreateTempateLiteralTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCreateRecursiveInstantiationError extends Error {
+export declare class ValueCreateRecursiveInstantiationError extends TypeBoxError {
     readonly schema: TSchema;
     readonly recursiveMaxDepth: number;
     constructor(schema: TSchema, recursiveMaxDepth: number);

package/build/import/value/create/create.mjs

@@ -5,45 +5,46 @@ import { TemplateLiteralGenerate, IsTemplateLiteralFinite } from '../../type/tem
 import { PatternStringExact, PatternNumberExact } from '../../type/patterns/index.mjs';
 import { TypeRegistry } from '../../type/registry/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueCreateUnknownTypeError extends Error {
+export class ValueCreateUnknownTypeError extends TypeBoxError {
     schema;
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
     }
 }
-export class ValueCreateNeverTypeError extends Error {
+export class ValueCreateNeverTypeError extends TypeBoxError {
     schema;
     constructor(schema) {
         super('Never types cannot be created');
         this.schema = schema;
     }
 }
-export class ValueCreateNotTypeError extends Error {
+export class ValueCreateNotTypeError extends TypeBoxError {
     schema;
     constructor(schema) {
         super('Not types must have a default value');
         this.schema = schema;
     }
 }
-export class ValueCreateIntersectTypeError extends Error {
+export class ValueCreateIntersectTypeError extends TypeBoxError {
     schema;
     constructor(schema) {
         super('Intersect produced invalid value. Consider using a default value.');
         this.schema = schema;
     }
 }
-export class ValueCreateTempateLiteralTypeError extends Error {
+export class ValueCreateTempateLiteralTypeError extends TypeBoxError {
     schema;
     constructor(schema) {
         super('Can only create template literal values from patterns that produce finite sequences. Consider using a default value.');
         this.schema = schema;
     }
 }
-export class ValueCreateRecursiveInstantiationError extends Error {
+export class ValueCreateRecursiveInstantiationError extends TypeBoxError {
     schema;
     recursiveMaxDepth;
     constructor(schema, recursiveMaxDepth) {

package/build/import/value/delta/delta.d.mts

@@ -1,4 +1,5 @@
 import type { Static } from '../../type/static/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
 export type Insert = Static<typeof Insert>;
 export declare const Insert: import("../../type/object/object.mjs").TObject<{
     type: import("../../type/literal/literal.mjs").TLiteral<"insert">;
@@ -29,11 +30,11 @@ export declare const Edit: import("../../type/union/union-type.mjs").TUnion<[imp
     type: import("../../type/literal/literal.mjs").TLiteral<"delete">;
     path: import("../../type/string/string.mjs").TString;
 }>]>;
-export declare class ValueDeltaObjectWithSymbolKeyError extends Error {
+export declare class ValueDeltaObjectWithSymbolKeyError extends TypeBoxError {
     readonly key: unknown;
     constructor(key: unknown);
 }
-export declare class ValueDeltaUnableToDiffUnknownValue extends Error {
+export declare class ValueDeltaUnableToDiffUnknownValue extends TypeBoxError {
     readonly value: unknown;
     constructor(value: unknown);
 }

package/build/import/value/delta/delta.mjs

@@ -1,6 +1,7 @@
 import { IsPlainObject, IsArray, IsTypedArray, IsValueType, IsSymbol, IsUndefined } from '../guard/index.mjs';
 import { ValuePointer } from '../pointer/index.mjs';
 import { Clone } from '../clone/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
 import { Literal as CreateLiteral } from '../../type/literal/index.mjs';
 import { Object as CreateObject } from '../../type/object/index.mjs';
 import { String as CreateString } from '../../type/string/index.mjs';
@@ -24,14 +25,14 @@ export const Edit = CreateUnion([Insert, Update, Delete]);
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueDeltaObjectWithSymbolKeyError extends Error {
+export class ValueDeltaObjectWithSymbolKeyError extends TypeBoxError {
     key;
     constructor(key) {
         super('Cannot diff objects with symbol keys');
         this.key = key;
     }
 }
-export class ValueDeltaUnableToDiffUnknownValue extends Error {
+export class ValueDeltaUnableToDiffUnknownValue extends TypeBoxError {
     value;
     constructor(value) {
         super('Unable to create diff edits for unknown value');

package/build/import/value/deref/deref.d.mts

@@ -1,7 +1,8 @@
 import type { TSchema } from '../../type/schema/index.mjs';
 import type { TRef } from '../../type/ref/index.mjs';
 import type { TThis } from '../../type/recursive/index.mjs';
-export declare class TypeDereferenceError extends Error {
+import { TypeBoxError } from '../../type/error/index.mjs';
+export declare class TypeDereferenceError extends TypeBoxError {
     readonly schema: TRef | TThis;
     constructor(schema: TRef | TThis);
 }

package/build/import/value/deref/deref.mjs

@@ -1,4 +1,5 @@
-export class TypeDereferenceError extends Error {
+import { TypeBoxError } from '../../type/error/index.mjs';
+export class TypeDereferenceError extends TypeBoxError {
     schema;
     constructor(schema) {
         super(`Unable to dereference schema with $id '${schema.$id}'`);

package/build/import/value/hash/hash.d.mts

@@ -1,4 +1,5 @@
-export declare class ValueHashError extends Error {
+import { TypeBoxError } from '../../type/error/index.mjs';
+export declare class ValueHashError extends TypeBoxError {
     readonly value: unknown;
     constructor(value: unknown);
 }