@sinclair/typebox 0.34.8 → 0.34.10

package/build/esm/type/indexed/indexed-property-keys.d.mts

@@ -4,11 +4,11 @@ import type { TInteger } from '../integer/index.mjs';
 import type { TNumber } from '../number/index.mjs';
 import type { TSchema } from '../schema/index.mjs';
 import type { TUnion } from '../union/index.mjs';
-type TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, Result extends string[] = TTemplateLiteralGenerate<TemplateLiteral>> = Result;
+type TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, Keys extends string[] = TTemplateLiteralGenerate<TemplateLiteral>> = (Keys);
 type TFromUnion<Types extends TSchema[], Result extends string[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TIndexPropertyKeys<Left>]> : Result);
 type TFromLiteral<LiteralValue extends TLiteralValue> = (LiteralValue extends PropertyKey ? [`${LiteralValue}`] : []);
-export type TIndexPropertyKeys<Type extends TSchema, Result extends PropertyKey[] = (Type extends TTemplateLiteral ? TFromTemplateLiteral<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TLiteral<infer LiteralValue extends TLiteralValue> ? TFromLiteral<LiteralValue> : Type extends TNumber ? ['[number]'] : Type extends TInteger ? ['[number]'] : [
-])> = Result;
+export type TIndexPropertyKeys<Type extends TSchema> = (Type extends TTemplateLiteral ? TFromTemplateLiteral<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Type extends TNumber ? ['[number]'] : Type extends TInteger ? ['[number]'] : [
+]);
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 export declare function IndexPropertyKeys<Type extends TSchema>(type: Type): TIndexPropertyKeys<Type>;
 export {};

package/build/esm/type/indexed/indexed-property-keys.mjs

@@ -5,19 +5,19 @@ import { TemplateLiteralGenerate } from '../template-literal/index.mjs';
 import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/kind.mjs';
 // prettier-ignore
 function FromTemplateLiteral(templateLiteral) {
-    const result = TemplateLiteralGenerate(templateLiteral);
-    return result.map(S => S.toString());
+    const keys = TemplateLiteralGenerate(templateLiteral);
+    return keys.map(key => key.toString());
 }
 // prettier-ignore
-function FromUnion(type) {
+function FromUnion(types) {
     const result = [];
-    for (const left of type)
-        result.push(...IndexPropertyKeys(left));
+    for (const type of types)
+        result.push(...IndexPropertyKeys(type));
     return result;
 }
 // prettier-ignore
-function FromLiteral(T) {
-    return ([T.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
+function FromLiteral(literalValue) {
+    return ([literalValue.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
     );
 }
 /** Returns a tuple of PropertyKeys derived from the given TSchema */

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

@@ -1,54 +1,52 @@
 import { type TSchema, SchemaOptions } from '../schema/index.mjs';
-import { type TComputed } from '../computed/index.mjs';
-import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
-import { type TObject, type TProperties } from '../object/index.mjs';
 import { type Assert } from '../helpers/index.mjs';
+import { type TComputed } from '../computed/index.mjs';
 import { type TNever } from '../never/index.mjs';
-import { type TRecursive } from '../recursive/index.mjs';
+import { type TArray } from '../array/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
-import { TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TUnion } from '../union/index.mjs';
-import { type TTuple } from '../tuple/index.mjs';
-import { type TArray } from '../array/index.mjs';
+import { type TRecursive } from '../recursive/index.mjs';
 import { type TRef } from '../ref/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
 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, Result extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Result, Assert<TIndexFromPropertyKey<L, K>, TSchema>]> : Result);
+type TFromRest<Types extends TSchema[], Key extends PropertyKey, Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<Right, Key, [...Result, Assert<TIndexFromPropertyKey<Left, Key>, TSchema>]> : Result);
 type TFromIntersectRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TNever ? TFromIntersectRest<Right, [...Result]> : TFromIntersectRest<Right, [...Result, Left]> : Result);
 type TFromIntersect<Types extends TSchema[], Key extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<Types, Key>>>);
 type TFromUnionRest<Types extends TSchema[], Result extends TSchema[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TNever ? [] : TFromUnionRest<Right, [Left, ...Result]> : Result;
 type TFromUnion<Types extends TSchema[], Key extends PropertyKey> = (TUnionEvaluated<TFromUnionRest<TFromRest<Types, Key>>>);
-type TFromTuple<Types extends TSchema[], Key extends PropertyKey, Result extends TSchema = (Key extends '[number]' ? TUnionEvaluated<Types> : Key extends keyof Types ? Types[Key] extends infer Type extends TSchema ? Type : TNever : TNever)> = Result;
+type TFromTuple<Types extends TSchema[], Key extends PropertyKey> = (Key extends keyof Types ? Types[Key] : Key extends '[number]' ? TUnionEvaluated<Types> : TNever);
 type TFromArray<Type extends TSchema, Key extends PropertyKey> = (Key extends '[number]' ? Type : TNever);
-type AssertPropertyKey<T extends unknown> = Assert<T, string | number>;
-type TFromProperty<Properties extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Properties ? Properties[Key] : `${AssertPropertyKey<Key>}` extends `${AssertPropertyKey<keyof Properties>}` ? Properties[AssertPropertyKey<Key>] : TNever)> = Result;
-export type TIndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = (Type extends TRecursive<infer S extends TSchema> ? TIndexFromPropertyKey<S, Key> : Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<S, Key> : Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<S, Key> : Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<S, Key> : Type extends TArray<infer S extends TSchema> ? TFromArray<S, Key> : Type extends TObject<infer S extends TProperties> ? TFromProperty<S, Key> : TNever);
-export declare function IndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key): TIndexFromPropertyKey<Type, Key>;
+type AssertPropertyKey<T> = Assert<T, string | number>;
+type TFromProperty<Properties extends TProperties, Key extends PropertyKey> = (Key extends keyof Properties ? Properties[Key] : `${AssertPropertyKey<Key>}` extends `${AssertPropertyKey<keyof Properties>}` ? Properties[AssertPropertyKey<Key>] : TNever);
+export type TIndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = (Type extends TRecursive<infer Type extends TSchema> ? TIndexFromPropertyKey<Type, Key> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types, Key> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types, Key> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Key> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Type, Key> : Type extends TObject<infer Properties extends TProperties> ? TFromProperty<Properties, Key> : TNever);
+export declare function IndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, propertyKey: Key): TIndexFromPropertyKey<Type, Key>;
 export type TIndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (PropertyKeys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? TIndexFromPropertyKeys<Type, Right, [...Result, Assert<TIndexFromPropertyKey<Type, Left>, TSchema>]> : Result);
 export declare function IndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): TIndexFromPropertyKeys<Type, PropertyKeys>;
-type TFromType<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TSchema[] = TIndexFromPropertyKeys<Type, PropertyKeys>> = TUnionEvaluated<Result>;
-type TUnionFromPropertyKeys<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = []> = (PropertyKeys extends [infer Key extends PropertyKey, ...infer Rest extends PropertyKey[]] ? Key extends TLiteralValue ? TUnionFromPropertyKeys<Rest, [...Result, TLiteral<Key>]> : TUnionFromPropertyKeys<Rest, [...Result]> : TUnionEvaluated<Result>);
-type TResolvePropertyKeys<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key;
-type TResolveTypeKey<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key;
-export type TIndex<Type extends TSchema, Key extends TSchema | PropertyKey[], IsTypeRef extends boolean = Type extends TRef ? true : false, IsKeyRef extends boolean = Key extends TRef ? true : false> = (Key extends TMappedResult ? TIndexFromMappedResult<Type, Key> : Key extends TMappedKey ? TIndexFromMappedKey<Type, Key> : [
-    IsTypeRef,
-    IsKeyRef
-] extends [true, true] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : [
-    IsTypeRef,
-    IsKeyRef
-] extends [false, true] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : [
-    IsTypeRef,
-    IsKeyRef
-] extends [true, false] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : TFromType<Type, TResolvePropertyKeys<Key>>);
-/** `[Json]` Returns an Indexed property type for the given keys */
-export declare function Index<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TIndex<Type, Key>;
-/** `[Json]` Returns an Indexed property type for the given keys */
-export declare function Index<Type extends TSchema, Key extends TMappedKey>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
-/** `[Json]` Returns an Indexed property type for the given keys */
-export declare function Index<Type extends TSchema, Key extends TMappedResult>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
-/** `[Json]` Returns an Indexed property type for the given keys */
-export declare function Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
+type FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (TUnionEvaluated<TIndexFromPropertyKeys<Type, PropertyKeys>>);
+declare function FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): FromSchema<Type, PropertyKeys>;
+export type TIndexFromComputed<Type extends TSchema, Key extends TSchema> = (TComputed<'Index', [Type, Key]>);
+export declare function IndexFromComputed<Type extends TSchema, Key extends TSchema>(type: Type, key: Key): TIndexFromComputed<Type, Key>;
+export type TIndex<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (FromSchema<Type, PropertyKeys>);
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TRef, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TRef, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TIndexFromMappedKey<Type, MappedKey>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, Key extends TSchema, PropertyKeys extends PropertyKey[] = TIndexPropertyKeys<Key>>(T: Type, K: Key, options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
 export {};

package/build/esm/type/indexed/indexed.mjs

@@ -1,27 +1,23 @@
 import { CreateType } from '../create/type.mjs';
+import { TypeBoxError } from '../error/index.mjs';
 import { Computed } from '../computed/index.mjs';
-import { Literal } from '../literal/index.mjs';
 import { Never } from '../never/index.mjs';
 import { IntersectEvaluated } from '../intersect/index.mjs';
 import { UnionEvaluated } from '../union/index.mjs';
-// ------------------------------------------------------------------
-// Infrastructure
-// ------------------------------------------------------------------
 import { IndexPropertyKeys } from './indexed-property-keys.mjs';
 import { IndexFromMappedKey } from './indexed-from-mapped-key.mjs';
 import { IndexFromMappedResult } from './indexed-from-mapped-result.mjs';
 // ------------------------------------------------------------------
-// KindGuard
+// TypeGuard
 // ------------------------------------------------------------------
-import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion, IsLiteralValue, IsRef } from '../guard/kind.mjs';
-import { IsArray as IsArrayValue } from '../guard/value.mjs';
+import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion, IsRef } from '../guard/kind.mjs';
 // prettier-ignore
 function FromRest(types, key) {
-    return types.map(left => IndexFromPropertyKey(left, key));
+    return types.map(type => IndexFromPropertyKey(type, key));
 }
 // prettier-ignore
 function FromIntersectRest(types) {
-    return types.filter(left => !IsNever(left));
+    return types.filter(type => !IsNever(type));
 }
 // prettier-ignore
 function FromIntersect(types, key) {
@@ -39,53 +35,57 @@ function FromUnion(types, key) {
 }
 // prettier-ignore
 function FromTuple(types, key) {
-    return (key === '[number]' ? UnionEvaluated(types) :
-        key in types ? types[key] :
+    return (key in types ? types[key] :
+        key === '[number]' ? UnionEvaluated(types) :
             Never());
 }
 // prettier-ignore
 function FromArray(type, key) {
-    // ... ?
-    return (key === '[number]' ? type : Never());
+    return (key === '[number]'
+        ? type
+        : Never());
 }
 // prettier-ignore
-function FromProperty(properties, key) {
-    return (key in properties ? properties[key] : Never());
+function FromProperty(properties, propertyKey) {
+    return (propertyKey in properties ? properties[propertyKey] : Never());
 }
 // prettier-ignore
-export function IndexFromPropertyKey(type, key) {
-    return (IsIntersect(type) ? FromIntersect(type.allOf, key) :
-        IsUnion(type) ? FromUnion(type.anyOf, key) :
-            IsTuple(type) ? FromTuple(type.items ?? [], key) :
-                IsArray(type) ? FromArray(type.items, key) :
-                    IsObject(type) ? FromProperty(type.properties, key) :
+export function IndexFromPropertyKey(type, propertyKey) {
+    return (IsIntersect(type) ? FromIntersect(type.allOf, propertyKey) :
+        IsUnion(type) ? FromUnion(type.anyOf, propertyKey) :
+            IsTuple(type) ? FromTuple(type.items ?? [], propertyKey) :
+                IsArray(type) ? FromArray(type.items, propertyKey) :
+                    IsObject(type) ? FromProperty(type.properties, propertyKey) :
                         Never());
 }
 // prettier-ignore
 export function IndexFromPropertyKeys(type, propertyKeys) {
-    return propertyKeys.map(left => IndexFromPropertyKey(type, left));
+    return propertyKeys.map(propertyKey => IndexFromPropertyKey(type, propertyKey));
 }
 // prettier-ignore
-function FromType(type, propertyKeys) {
-    const result = IndexFromPropertyKeys(type, propertyKeys);
-    return UnionEvaluated(result);
+function FromSchema(type, propertyKeys) {
+    return (UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys)));
 }
 // prettier-ignore
-function UnionFromPropertyKeys(propertyKeys) {
-    const result = propertyKeys.reduce((result, key) => IsLiteralValue(key) ? [...result, Literal(key)] : result, []);
-    return UnionEvaluated(result);
+export function IndexFromComputed(type, key) {
+    return Computed('Index', [type, key]);
 }
 /** `[Json]` Returns an Indexed property type for the given keys */
-// prettier-ignore
 export function Index(type, key, options) {
-    const typeKey = IsArrayValue(key) ? UnionFromPropertyKeys(key) : key;
-    const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
-    const isTypeRef = IsRef(type);
-    const isKeyRef = IsRef(key);
-    return (IsMappedResult(key) ? IndexFromMappedResult(type, key, options) :
-        IsMappedKey(key) ? IndexFromMappedKey(type, key, options) :
-            (isTypeRef && isKeyRef) ? Computed('Index', [type, typeKey], options) :
-                (!isTypeRef && isKeyRef) ? Computed('Index', [type, typeKey], options) :
-                    (isTypeRef && !isKeyRef) ? Computed('Index', [type, typeKey], options) :
-                        CreateType(FromType(type, propertyKeys), options));
+    // computed-type
+    if (IsRef(type) || IsRef(key)) {
+        const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
+        if (!IsSchema(type) || !IsSchema(key))
+            throw new TypeBoxError(error);
+        return Computed('Index', [type, key]);
+    }
+    // mapped-types
+    if (IsMappedResult(key))
+        return IndexFromMappedResult(type, key, options);
+    if (IsMappedKey(key))
+        return IndexFromMappedKey(type, key, options);
+    // prettier-ignore
+    return CreateType(IsSchema(key)
+        ? FromSchema(type, IndexPropertyKeys(key))
+        : FromSchema(type, key), options);
 }

package/build/esm/type/module/compute.d.mts

@@ -5,8 +5,8 @@ import { type TAwaited } from '../awaited/index.mjs';
 import { type TAsyncIterator } from '../async-iterator/index.mjs';
 import { TComputed } from '../computed/index.mjs';
 import { type TConstructor } from '../constructor/index.mjs';
-import { type TIndex } from '../indexed/index.mjs';
-import { TEnum, TEnumRecord } from '../enum/index.mjs';
+import { type TIndex, type TIndexPropertyKeys } from '../indexed/index.mjs';
+import { TEnum, type TEnumRecord } from '../enum/index.mjs';
 import { type TFunction } from '../function/index.mjs';
 import { type TIntersect, type TIntersectEvaluated } from '../intersect/index.mjs';
 import { type TIterator } from '../iterator/index.mjs';
@@ -26,7 +26,7 @@ import { type TUnion, type TUnionEvaluated } from '../union/index.mjs';
 type TDerefParameters<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TRef<infer Key extends string> ? TDerefParameters<ModuleProperties, Right, [...Result, TDeref<ModuleProperties, Key>]> : TDerefParameters<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
 type TDeref<ModuleProperties extends TProperties, Ref extends string, Result extends TSchema = (Ref extends keyof ModuleProperties ? ModuleProperties[Ref] extends TRef<infer Ref2 extends string> ? TDeref<ModuleProperties, Ref2> : TFromType<ModuleProperties, ModuleProperties[Ref]> : TNever)> = Result;
 type TFromAwaited<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TAwaited<T0> : never);
-type TFromIndex<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TIndex<T0, T1> : never);
+type TFromIndex<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TIndex<T0, TIndexPropertyKeys<T1>> extends infer Result extends TSchema ? Result : never : never);
 type TFromKeyOf<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TKeyOf<T0> : never);
 type TFromPartial<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TPartial<T0> : never);
 type TFromOmit<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TOmit<T0, T1> : never);

package/build/esm/type/module/compute.mjs

@@ -127,9 +127,6 @@ export function FromType(moduleProperties, type) {
             // Traveral
             KindGuard.IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) :
                 KindGuard.IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) :
-                    // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
-                    // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
-                    // be a priority as there is a potential for the current inference to break on TS compiler changes.
                     KindGuard.IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters)) :
                         KindGuard.IsConstructor(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
                             KindGuard.IsFunction(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) :

package/build/esm/type/module/infer.d.mts

@@ -37,7 +37,9 @@ type InferProperties<ModuleProperties extends TProperties, Properties extends TP
 }>;
 type TInferObject<ModuleProperties extends TProperties, Properties extends TProperties> = (InferProperties<ModuleProperties, Properties>);
 type TInferTuple<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferTuple<ModuleProperties, R, [...Result, TInfer<ModuleProperties, L>]> : Result);
-type TInferRecord<ModuleProperties extends TProperties, Key extends TSchema, Type extends TSchema, InferredKey extends PropertyKey = TInfer<ModuleProperties, Key> extends infer Key extends PropertyKey ? Key : never, InferedType extends unknown = TInfer<ModuleProperties, Type>> = Record<InferredKey, InferedType>;
+type TInferRecord<ModuleProperties extends TProperties, Key extends TSchema, Type extends TSchema, InferredKey extends PropertyKey = TInfer<ModuleProperties, Key> extends infer Key extends PropertyKey ? Key : never, InferedType extends unknown = TInfer<ModuleProperties, Type>> = Ensure<{
+    [_ in InferredKey]: InferedType;
+}>;
 type TInferRef<ModuleProperties extends TProperties, Ref extends string> = (Ref extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Ref]> : unknown);
 type TInferUnion<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = never> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferUnion<ModuleProperties, R, Result | TInfer<ModuleProperties, L>> : Result);
 type TInfer<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TInferArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TInferAsyncIterator<ModuleProperties, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TInferConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TInferFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TInferIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TInferIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TInferObject<ModuleProperties, Properties> : Type extends TRecord<infer Key extends TSchema, infer Type extends TSchema> ? TInferRecord<ModuleProperties, Key, Type> : Type extends TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Static<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> : Static<Type>);

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

@@ -52,7 +52,7 @@ export interface TRecord<Key extends TSchema = TSchema, Type extends TSchema = T
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [Key, TComputed<Target, Parameters>]> : Key extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [TComputed<Target, Parameters>, Type]> : Key extends TRef<infer Ref extends string> ? TComputed<'Record', [TRef<Ref>, Type]> : Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer Enum extends TEnumRecord> ? TFromEnumKey<Enum, Type> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Type> : Key extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteralKey<Value, Type> : Key extends TInteger ? TFromIntegerKey<Key, Type> : Key extends TNumber ? TFromNumberKey<Key, Type> : Key extends TRegExp ? TFromRegExpKey<Key, Type> : Key extends TString ? TFromStringKey<Key, Type> : Key extends TAny ? TFromAnyKey<Key, Type> : Key extends TNever ? TFromNeverKey<Key, Type> : Key);
+export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [Key, TComputed<Target, Parameters>]> : Key extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [TComputed<Target, Parameters>, Type]> : Key extends TRef<infer Ref extends string> ? TComputed<'Record', [TRef<Ref>, Type]> : Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer Enum extends TEnumRecord> ? TFromEnumKey<Enum, Type> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Type> : Key extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteralKey<Value, Type> : Key extends TInteger ? TFromIntegerKey<Key, Type> : Key extends TNumber ? TFromNumberKey<Key, Type> : Key extends TRegExp ? TFromRegExpKey<Key, Type> : Key extends TString ? TFromStringKey<Key, Type> : Key extends TAny ? TFromAnyKey<Key, Type> : Key extends TNever ? TFromNeverKey<Key, Type> : TNever);
 /** `[Json]` Creates a Record type */
 export declare function Record<Key extends TSchema, Type extends TSchema>(key: Key, type: Type, options?: ObjectOptions): TRecordOrObject<Key, Type>;
 export {};

package/build/esm/type/type/json.d.mts

@@ -7,7 +7,7 @@ import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index.mjs';
 import { type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index.mjs';
 import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index.mjs';
 import { type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from '../extract/index.mjs';
-import { TIndex, type TIndexPropertyKeys } from '../indexed/index.mjs';
+import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult, type TIndexFromComputed } 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,13 +93,19 @@ 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<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, key: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+    Index<Type extends TRef, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, Key extends TMappedKey>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
+    Index<Type extends TSchema, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, Key extends TMappedResult>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
+    Index<Type extends TRef, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
+    Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TIndexFromMappedKey<Type, MappedKey>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, Key extends TSchema, PropertyKeys extends PropertyKey[] = TIndexPropertyKeys<Key>>(T: Type, K: Key, options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+    /** `[Json]` Returns an Indexed property type for the given keys */
+    Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
     /** `[Json]` Creates an Integer type */
     Integer(options?: IntegerOptions): TInteger;
     /** `[Json]` Creates an Intersect type */

package/build/esm/value/parse/parse.d.mts

@@ -1,6 +1,22 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
 import { TSchema } from '../../type/schema/index.mjs';
 import { StaticDecode } from '../../type/static/index.mjs';
-/** Parses a value or throws an `AssertError` if invalid. */
-export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
-/** Parses a value or throws an `AssertError` if invalid. */
-export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
+export declare class ParseError extends TypeBoxError {
+    constructor(message: string);
+}
+export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | 'Encode' | ({} & string);
+export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown;
+export declare namespace ParseRegistry {
+    function Delete(key: string): void;
+    function Set(key: string, callback: TParseFunction): void;
+    function Get(key: string): TParseFunction | undefined;
+}
+export declare const ParseDefault: readonly ["Clone", "Clean", "Default", "Convert", "Assert", "Decode"];
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, references: TSchema[], value: unknown): Result;
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, value: unknown): Result;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, references: TSchema[], value: unknown): unknown;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, value: unknown): unknown;

package/build/esm/value/parse/parse.mjs

@@ -1,25 +1,79 @@
-import { TransformDecode, HasTransform } from '../transform/index.mjs';
-import { Assert } from '../assert/assert.mjs';
-import { Default } from '../default/default.mjs';
-import { Convert } from '../convert/convert.mjs';
-import { Clean } from '../clean/clean.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
+import { TransformDecode, TransformEncode, HasTransform } from '../transform/index.mjs';
+import { Assert } from '../assert/index.mjs';
+import { Default } from '../default/index.mjs';
+import { Convert } from '../convert/index.mjs';
+import { Clean } from '../clean/index.mjs';
 import { Clone } from '../clone/index.mjs';
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+import { IsArray, IsUndefined } from '../guard/index.mjs';
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export class ParseError extends TypeBoxError {
+    constructor(message) {
+        super(message);
+    }
+}
+// prettier-ignore
+export var ParseRegistry;
+(function (ParseRegistry) {
+    const registry = new Map([
+        ['Clone', (_type, _references, value) => Clone(value)],
+        ['Clean', (type, references, value) => Clean(type, references, value)],
+        ['Default', (type, references, value) => Default(type, references, value)],
+        ['Convert', (type, references, value) => Convert(type, references, value)],
+        ['Assert', (type, references, value) => { Assert(type, references, value); return value; }],
+        ['Decode', (type, references, value) => (HasTransform(type, references) ? TransformDecode(type, references, value) : value)],
+        ['Encode', (type, references, value) => (HasTransform(type, references) ? TransformEncode(type, references, value) : value)],
+    ]);
+    // Deletes an entry from the registry
+    function Delete(key) {
+        registry.delete(key);
+    }
+    ParseRegistry.Delete = Delete;
+    // Sets an entry in the registry
+    function Set(key, callback) {
+        registry.set(key, callback);
+    }
+    ParseRegistry.Set = Set;
+    // Gets an entry in the registry
+    function Get(key) {
+        return registry.get(key);
+    }
+    ParseRegistry.Get = Get;
+})(ParseRegistry || (ParseRegistry = {}));
+// ------------------------------------------------------------------
+// Default Parse Sequence
+// ------------------------------------------------------------------
 // prettier-ignore
-const ParseReducer = [
-    (_schema, _references, value) => Clone(value),
-    (schema, references, value) => Default(schema, references, value),
-    (schema, references, value) => Clean(schema, references, value),
-    (schema, references, value) => Convert(schema, references, value),
-    (schema, references, value) => { Assert(schema, references, value); return value; },
-    (schema, references, value) => (HasTransform(schema, references) ? TransformDecode(schema, references, value) : value),
+export const ParseDefault = [
+    'Clone',
+    'Clean',
+    'Default',
+    'Convert',
+    'Assert',
+    'Decode'
 ];
 // ------------------------------------------------------------------
 // ParseValue
 // ------------------------------------------------------------------
-function ParseValue(schema, references, value) {
-    return ParseReducer.reduce((value, reducer) => reducer(schema, references, value), value);
+function ParseValue(operations, type, references, value) {
+    return operations.reduce((value, operationKey) => {
+        const operation = ParseRegistry.Get(operationKey);
+        if (IsUndefined(operation))
+            throw new ParseError(`Unable to find Parse operation '${operationKey}'`);
+        return operation(type, references, value);
+    }, value);
 }
-/** Parses a value or throws an `AssertError` if invalid. */
+/** Parses a value */
 export function Parse(...args) {
-    return args.length === 3 ? ParseValue(args[0], args[1], args[2]) : ParseValue(args[0], [], args[1]);
+    // prettier-ignore
+    const [operations, schema, references, value] = (args.length === 4 ? [args[0], args[1], args[2], args[3]] :
+        args.length === 3 ? IsArray(args[0]) ? [args[0], args[1], [], args[2]] : [ParseDefault, args[0], args[1], args[2]] :
+            args.length === 2 ? [ParseDefault, args[0], [], args[1]] :
+                (() => { throw new ParseError('Invalid Arguments'); })());
+    return ParseValue(operations, schema, references, value);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.8",
+  "version": "0.34.10",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",