@sinclair/typebox 0.32.0-dev-23 → 0.32.0-dev-25

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';
@@ -21,7 +22,7 @@ export { Extends, type TExtends, type ExtendsFromMappedResult, type ExtendsFromM
 export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index.mjs';
 export { Function, type TFunction } from './type/function/index.mjs';
 export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index.mjs';
-export { Index, IndexPropertyKeys, IndexFromMappedKey, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from './type/indexed/index.mjs';
+export { Index, IndexPropertyKeys, IndexFromMappedKey, IndexFromMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from './type/indexed/index.mjs';
 export { InstanceType, type TInstanceType } from './type/instance-type/index.mjs';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index.mjs';
 export { Intersect, IntersectEvaluated, type TIntersect, type TIntersectEvaluated, type IntersectOptions } from './type/intersect/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
 // ------------------------------------------------------------------
@@ -27,7 +28,7 @@ export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './t
 export { Extract } from './type/extract/index.mjs';
 export { Function } from './type/function/index.mjs';
 export { Increment } from './type/helpers/index.mjs';
-export { Index, IndexPropertyKeys, IndexFromMappedKey } from './type/indexed/index.mjs';
+export { Index, IndexPropertyKeys, IndexFromMappedKey, IndexFromMappedResult } from './type/indexed/index.mjs';
 export { InstanceType } from './type/instance-type/index.mjs';
 export { Integer } from './type/integer/index.mjs';
 export { Intersect, IntersectEvaluated } from './type/intersect/index.mjs';

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/indexed/index.d.mts

@@ -1,3 +1,4 @@
 export * from './indexed-from-mapped-key.mjs';
+export * from './indexed-from-mapped-result.mjs';
 export * from './indexed-property-keys.mjs';
 export * from './indexed.mjs';

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

@@ -1,3 +1,4 @@
 export * from './indexed-from-mapped-key.mjs';
+export * from './indexed-from-mapped-result.mjs';
 export * from './indexed-property-keys.mjs';
 export * from './indexed.mjs';

package/build/import/type/indexed/indexed-from-mapped-result.d.mts

@@ -0,0 +1,12 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TIndex } from './index.mjs';
+import { TIndexPropertyKeys } from './indexed-property-keys.mjs';
+type TFromProperties<T extends TSchema, P extends TProperties> = ({
+    [K2 in keyof P]: TIndex<T, TIndexPropertyKeys<P[K2]>>;
+});
+type TFromMappedResult<T extends TSchema, K extends TMappedResult> = (TFromProperties<T, K['properties']>);
+export type TIndexFromMappedResult<T extends TSchema, R extends TMappedResult, P extends TProperties = TFromMappedResult<T, R>> = (TMappedResult<P>);
+export declare function IndexFromMappedResult<T extends TSchema, R extends TMappedResult, P extends TProperties = TFromMappedResult<T, R>>(T: T, R: R, options: SchemaOptions): TMappedResult<P>;
+export {};

package/build/import/type/indexed/indexed-from-mapped-result.mjs

@@ -0,0 +1,18 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Index } from './index.mjs';
+import { IndexPropertyKeys } from './indexed-property-keys.mjs';
+// prettier-ignore
+function FromProperties(T, P, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Index(T, IndexPropertyKeys(P[K2]), options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedResult(T, R, options) {
+    return FromProperties(T, R.properties, options);
+}
+// prettier-ignore
+export function IndexFromMappedResult(T, R, options) {
+    const P = FromMappedResult(T, R, options);
+    return MappedResult(P);
+}

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

@@ -4,7 +4,7 @@ import { type Assert } from '../helpers/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { type TRecursive } from '../recursive/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
-import { type TMappedKey } from '../mapped/index.mjs';
+import { TMappedResult, type TMappedKey } from '../mapped/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TTuple } from '../tuple/index.mjs';
 import { type TArray } from '../array/index.mjs';
@@ -12,6 +12,7 @@ import { type TIntersectEvaluated } from '../intersect/index.mjs';
 import { type TUnionEvaluated } from '../union/index.mjs';
 import { type TIndexPropertyKeys } from './indexed-property-keys.mjs';
 import { type TIndexFromMappedKey } from './indexed-from-mapped-key.mjs';
+import { type TIndexFromMappedResult } from './indexed-from-mapped-result.mjs';
 type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Acc, Assert<TFromKey<L, K>, TSchema>]> : Acc);
 type TFromIntersectRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? TFromIntersectRest<R, [...Acc]> : TFromIntersectRest<R, [...Acc, L]> : Acc);
 type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<T, K>>>);
@@ -27,6 +28,8 @@ type FromSchema<T extends TSchema, K extends PropertyKey[]> = (TUnionEvaluated<T
 declare function FromSchema<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromSchema<T, K>;
 export type TIndex<T extends TSchema, K extends PropertyKey[]> = (FromSchema<T, K>);
 /** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>;
+/** `[Json]` Returns an Indexed property type for the given keys */
 export declare function Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
 /** `[Json]` Returns an Indexed property type for the given keys */
 export declare function Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;

package/build/import/type/indexed/indexed.mjs

@@ -4,11 +4,11 @@ import { UnionEvaluated } from '../union/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { IndexPropertyKeys } from './indexed-property-keys.mjs';
 import { IndexFromMappedKey } from './indexed-from-mapped-key.mjs';
+import { IndexFromMappedResult } from './indexed-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-import { IsArray, IsIntersect, IsObject, IsMappedKey, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/type.mjs';
+import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/type.mjs';
 // prettier-ignore
 function FromRest(T, K, Acc = []) {
     const [L, ...R] = T;
@@ -83,7 +83,8 @@ function FromSchema(T, K) {
 /** `[Json]` Returns an Indexed property type for the given keys */
 export function Index(T, K, options = {}) {
     // prettier-ignore
-    return (IsMappedKey(K) ? CloneType(IndexFromMappedKey(T, K, options)) :
-        IsSchema(K) ? CloneType(FromSchema(T, IndexPropertyKeys(K)), options) :
-            CloneType(FromSchema(T, K), options));
+    return (IsMappedResult(K) ? CloneType(IndexFromMappedResult(T, K, options)) :
+        IsMappedKey(K) ? CloneType(IndexFromMappedKey(T, K, options)) :
+            IsSchema(K) ? CloneType(FromSchema(T, IndexPropertyKeys(K)), options) :
+                CloneType(FromSchema(T, K), options));
 }

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,11 +1,12 @@
 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;

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/type/type/json.d.mts

@@ -8,7 +8,7 @@ import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index.mjs';
 import { type TExclude, type TExcludeFromMappedResult } from '../exclude/index.mjs';
 import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index.mjs';
 import { type TExtract, type TExtractFromMappedResult } from '../extract/index.mjs';
-import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from '../indexed/index.mjs';
+import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from '../indexed/index.mjs';
 import { type IntegerOptions, type TInteger } from '../integer/index.mjs';
 import { Intersect, type IntersectOptions } from '../intersect/index.mjs';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index.mjs';
@@ -93,6 +93,8 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
     /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
     /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;

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);