@sinclair/typebox 0.34.8 → 0.34.10

package/build/cjs/compiler/compiler.d.ts

@@ -12,6 +12,10 @@ export declare class TypeCheck<T extends TSchema> {
     constructor(schema: T, references: TSchema[], checkFunc: CheckFunction, code: string);
     /** Returns the generated assertion code used to validate this type. */
     Code(): string;
+    /** Returns the schema type used to validate */
+    Schema(): T;
+    /** Returns reference types used to validate */
+    References(): TSchema[];
     /** Returns an iterator for each error in this value. */
     Errors(value: unknown): ValueErrorIterator;
     /** Returns true if the value matches the compiled type. */

package/build/cjs/compiler/compiler.js

@@ -36,6 +36,14 @@ class TypeCheck {
     Code() {
         return this.code;
     }
+    /** Returns the schema type used to validate */
+    Schema() {
+        return this.schema;
+    }
+    /** Returns reference types used to validate */
+    References() {
+        return this.references;
+    }
     /** Returns an iterator for each error in this value. */
     Errors(value) {
         return (0, index_2.Errors)(this.schema, this.references, value);

package/build/cjs/syntax/runtime.d.ts

@@ -48,7 +48,7 @@ export declare const Module: Runtime.Module<{
     Iterator: Runtime.ITuple<Types.TIterator<Types.TSchema>>;
     Awaited: Runtime.ITuple<Types.TSchema>;
     Array: Runtime.ITuple<Types.TArray<Types.TSchema>>;
-    Record: Runtime.ITuple<Types.TSchema>;
+    Record: Runtime.ITuple<Types.TNever>;
     Promise: Runtime.ITuple<Types.TPromise<Types.TSchema>>;
     ConstructorParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
     FunctionParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;

package/build/cjs/type/indexed/indexed-from-mapped-result.js

@@ -9,8 +9,7 @@ const index_2 = require("./index");
 function FromProperties(type, properties, options) {
     const result = {};
     for (const K2 of Object.getOwnPropertyNames(properties)) {
-        const keys = (0, indexed_property_keys_1.IndexPropertyKeys)(properties[K2]);
-        result[K2] = (0, index_2.Index)(type, keys, options);
+        result[K2] = (0, index_2.Index)(type, (0, indexed_property_keys_1.IndexPropertyKeys)(properties[K2]), options);
     }
     return result;
 }

package/build/cjs/type/indexed/indexed-property-keys.d.ts

@@ -4,11 +4,11 @@ import type { TInteger } from '../integer/index';
 import type { TNumber } from '../number/index';
 import type { TSchema } from '../schema/index';
 import type { TUnion } from '../union/index';
-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/cjs/type/indexed/indexed-property-keys.js

@@ -9,19 +9,19 @@ const index_1 = require("../template-literal/index");
 const kind_1 = require("../guard/kind");
 // prettier-ignore
 function FromTemplateLiteral(templateLiteral) {
-    const result = (0, index_1.TemplateLiteralGenerate)(templateLiteral);
-    return result.map(S => S.toString());
+    const keys = (0, index_1.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/cjs/type/indexed/indexed.d.ts

@@ -1,54 +1,52 @@
 import { type TSchema, SchemaOptions } from '../schema/index';
-import { type TComputed } from '../computed/index';
-import { type TLiteral, type TLiteralValue } from '../literal/index';
-import { type TObject, type TProperties } from '../object/index';
 import { type Assert } from '../helpers/index';
+import { type TComputed } from '../computed/index';
 import { type TNever } from '../never/index';
-import { type TRecursive } from '../recursive/index';
+import { type TArray } from '../array/index';
 import { type TIntersect } from '../intersect/index';
-import { TMappedResult, type TMappedKey } from '../mapped/index';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+import { type TObject, type TProperties } from '../object/index';
 import { type TUnion } from '../union/index';
-import { type TTuple } from '../tuple/index';
-import { type TArray } from '../array/index';
+import { type TRecursive } from '../recursive/index';
 import { type TRef } from '../ref/index';
+import { type TTuple } from '../tuple/index';
 import { type TIntersectEvaluated } from '../intersect/index';
 import { type TUnionEvaluated } from '../union/index';
 import { type TIndexPropertyKeys } from './indexed-property-keys';
 import { type TIndexFromMappedKey } from './indexed-from-mapped-key';
 import { type TIndexFromMappedResult } from './indexed-from-mapped-result';
-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/cjs/type/indexed/indexed.js

@@ -3,31 +3,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexFromPropertyKey = IndexFromPropertyKey;
 exports.IndexFromPropertyKeys = IndexFromPropertyKeys;
+exports.IndexFromComputed = IndexFromComputed;
 exports.Index = Index;
 const type_1 = require("../create/type");
-const index_1 = require("../computed/index");
-const index_2 = require("../literal/index");
+const index_1 = require("../error/index");
+const index_2 = require("../computed/index");
 const index_3 = require("../never/index");
 const index_4 = require("../intersect/index");
 const index_5 = require("../union/index");
-// ------------------------------------------------------------------
-// Infrastructure
-// ------------------------------------------------------------------
 const indexed_property_keys_1 = require("./indexed-property-keys");
 const indexed_from_mapped_key_1 = require("./indexed-from-mapped-key");
 const indexed_from_mapped_result_1 = require("./indexed-from-mapped-result");
 // ------------------------------------------------------------------
-// KindGuard
+// TypeGuard
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
-const value_1 = require("../guard/value");
 // 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 => !(0, kind_1.IsNever)(left));
+    return types.filter(type => !(0, kind_1.IsNever)(type));
 }
 // prettier-ignore
 function FromIntersect(types, key) {
@@ -45,53 +42,57 @@ function FromUnion(types, key) {
 }
 // prettier-ignore
 function FromTuple(types, key) {
-    return (key === '[number]' ? (0, index_5.UnionEvaluated)(types) :
-        key in types ? types[key] :
+    return (key in types ? types[key] :
+        key === '[number]' ? (0, index_5.UnionEvaluated)(types) :
             (0, index_3.Never)());
 }
 // prettier-ignore
 function FromArray(type, key) {
-    // ... ?
-    return (key === '[number]' ? type : (0, index_3.Never)());
+    return (key === '[number]'
+        ? type
+        : (0, index_3.Never)());
 }
 // prettier-ignore
-function FromProperty(properties, key) {
-    return (key in properties ? properties[key] : (0, index_3.Never)());
+function FromProperty(properties, propertyKey) {
+    return (propertyKey in properties ? properties[propertyKey] : (0, index_3.Never)());
 }
 // prettier-ignore
-function IndexFromPropertyKey(type, key) {
-    return ((0, kind_1.IsIntersect)(type) ? FromIntersect(type.allOf, key) :
-        (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf, key) :
-            (0, kind_1.IsTuple)(type) ? FromTuple(type.items ?? [], key) :
-                (0, kind_1.IsArray)(type) ? FromArray(type.items, key) :
-                    (0, kind_1.IsObject)(type) ? FromProperty(type.properties, key) :
+function IndexFromPropertyKey(type, propertyKey) {
+    return ((0, kind_1.IsIntersect)(type) ? FromIntersect(type.allOf, propertyKey) :
+        (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf, propertyKey) :
+            (0, kind_1.IsTuple)(type) ? FromTuple(type.items ?? [], propertyKey) :
+                (0, kind_1.IsArray)(type) ? FromArray(type.items, propertyKey) :
+                    (0, kind_1.IsObject)(type) ? FromProperty(type.properties, propertyKey) :
                         (0, index_3.Never)());
 }
 // prettier-ignore
 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 (0, index_5.UnionEvaluated)(result);
+function FromSchema(type, propertyKeys) {
+    return ((0, index_5.UnionEvaluated)(IndexFromPropertyKeys(type, propertyKeys)));
 }
 // prettier-ignore
-function UnionFromPropertyKeys(propertyKeys) {
-    const result = propertyKeys.reduce((result, key) => (0, kind_1.IsLiteralValue)(key) ? [...result, (0, index_2.Literal)(key)] : result, []);
-    return (0, index_5.UnionEvaluated)(result);
+function IndexFromComputed(type, key) {
+    return (0, index_2.Computed)('Index', [type, key]);
 }
 /** `[Json]` Returns an Indexed property type for the given keys */
-// prettier-ignore
 function Index(type, key, options) {
-    const typeKey = (0, value_1.IsArray)(key) ? UnionFromPropertyKeys(key) : key;
-    const propertyKeys = (0, kind_1.IsSchema)(key) ? (0, indexed_property_keys_1.IndexPropertyKeys)(key) : key;
-    const isTypeRef = (0, kind_1.IsRef)(type);
-    const isKeyRef = (0, kind_1.IsRef)(key);
-    return ((0, kind_1.IsMappedResult)(key) ? (0, indexed_from_mapped_result_1.IndexFromMappedResult)(type, key, options) :
-        (0, kind_1.IsMappedKey)(key) ? (0, indexed_from_mapped_key_1.IndexFromMappedKey)(type, key, options) :
-            (isTypeRef && isKeyRef) ? (0, index_1.Computed)('Index', [type, typeKey], options) :
-                (!isTypeRef && isKeyRef) ? (0, index_1.Computed)('Index', [type, typeKey], options) :
-                    (isTypeRef && !isKeyRef) ? (0, index_1.Computed)('Index', [type, typeKey], options) :
-                        (0, type_1.CreateType)(FromType(type, propertyKeys), options));
+    // computed-type
+    if ((0, kind_1.IsRef)(type) || (0, kind_1.IsRef)(key)) {
+        const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
+        if (!(0, kind_1.IsSchema)(type) || !(0, kind_1.IsSchema)(key))
+            throw new index_1.TypeBoxError(error);
+        return (0, index_2.Computed)('Index', [type, key]);
+    }
+    // mapped-types
+    if ((0, kind_1.IsMappedResult)(key))
+        return (0, indexed_from_mapped_result_1.IndexFromMappedResult)(type, key, options);
+    if ((0, kind_1.IsMappedKey)(key))
+        return (0, indexed_from_mapped_key_1.IndexFromMappedKey)(type, key, options);
+    // prettier-ignore
+    return (0, type_1.CreateType)((0, kind_1.IsSchema)(key)
+        ? FromSchema(type, (0, indexed_property_keys_1.IndexPropertyKeys)(key))
+        : FromSchema(type, key), options);
 }

package/build/cjs/type/module/compute.d.ts

@@ -5,8 +5,8 @@ import { type TAwaited } from '../awaited/index';
 import { type TAsyncIterator } from '../async-iterator/index';
 import { TComputed } from '../computed/index';
 import { type TConstructor } from '../constructor/index';
-import { type TIndex } from '../indexed/index';
-import { TEnum, TEnumRecord } from '../enum/index';
+import { type TIndex, type TIndexPropertyKeys } from '../indexed/index';
+import { TEnum, type TEnumRecord } from '../enum/index';
 import { type TFunction } from '../function/index';
 import { type TIntersect, type TIntersectEvaluated } from '../intersect/index';
 import { type TIterator } from '../iterator/index';
@@ -26,7 +26,7 @@ import { type TUnion, type TUnionEvaluated } from '../union/index';
 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/cjs/type/module/compute.js

@@ -133,9 +133,6 @@ function FromType(moduleProperties, type) {
             // Traveral
             KindGuard.IsArray(type) ? (0, index_1.CreateType)(FromArray(moduleProperties, type.items), type) :
                 KindGuard.IsAsyncIterator(type) ? (0, index_1.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) ? (0, index_1.CreateType)(FromComputed(moduleProperties, type.target, type.parameters)) :
                         KindGuard.IsConstructor(type) ? (0, index_1.CreateType)(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
                             KindGuard.IsFunction(type) ? (0, index_1.CreateType)(FromFunction(moduleProperties, type.parameters, type.returns), type) :

package/build/cjs/type/module/infer.d.ts

@@ -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/cjs/type/record/record.d.ts

@@ -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/cjs/type/type/json.d.ts

@@ -7,7 +7,7 @@ import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index';
 import { type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index';
 import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index';
 import { type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from '../extract/index';
-import { TIndex, type TIndexPropertyKeys } from '../indexed/index';
+import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult, type TIndexFromComputed } from '../indexed/index';
 import { type IntegerOptions, type TInteger } from '../integer/index';
 import { Intersect, type IntersectOptions } from '../intersect/index';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index';
@@ -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/cjs/value/parse/parse.d.ts

@@ -1,6 +1,22 @@
+import { TypeBoxError } from '../../type/error/index';
 import { TSchema } from '../../type/schema/index';
 import { StaticDecode } from '../../type/static/index';
-/** 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/cjs/value/parse/parse.js

@@ -1,29 +1,85 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseDefault = exports.ParseRegistry = exports.ParseError = void 0;
 exports.Parse = Parse;
-const index_1 = require("../transform/index");
-const assert_1 = require("../assert/assert");
-const default_1 = require("../default/default");
-const convert_1 = require("../convert/convert");
-const clean_1 = require("../clean/clean");
-const index_2 = require("../clone/index");
+const index_1 = require("../../type/error/index");
+const index_2 = require("../transform/index");
+const index_3 = require("../assert/index");
+const index_4 = require("../default/index");
+const index_5 = require("../convert/index");
+const index_6 = require("../clean/index");
+const index_7 = require("../clone/index");
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+const index_8 = require("../guard/index");
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+class ParseError extends index_1.TypeBoxError {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.ParseError = ParseError;
+// prettier-ignore
+var ParseRegistry;
+(function (ParseRegistry) {
+    const registry = new Map([
+        ['Clone', (_type, _references, value) => (0, index_7.Clone)(value)],
+        ['Clean', (type, references, value) => (0, index_6.Clean)(type, references, value)],
+        ['Default', (type, references, value) => (0, index_4.Default)(type, references, value)],
+        ['Convert', (type, references, value) => (0, index_5.Convert)(type, references, value)],
+        ['Assert', (type, references, value) => { (0, index_3.Assert)(type, references, value); return value; }],
+        ['Decode', (type, references, value) => ((0, index_2.HasTransform)(type, references) ? (0, index_2.TransformDecode)(type, references, value) : value)],
+        ['Encode', (type, references, value) => ((0, index_2.HasTransform)(type, references) ? (0, index_2.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 || (exports.ParseRegistry = ParseRegistry = {}));
+// ------------------------------------------------------------------
+// Default Parse Sequence
+// ------------------------------------------------------------------
 // prettier-ignore
-const ParseReducer = [
-    (_schema, _references, value) => (0, index_2.Clone)(value),
-    (schema, references, value) => (0, default_1.Default)(schema, references, value),
-    (schema, references, value) => (0, clean_1.Clean)(schema, references, value),
-    (schema, references, value) => (0, convert_1.Convert)(schema, references, value),
-    (schema, references, value) => { (0, assert_1.Assert)(schema, references, value); return value; },
-    (schema, references, value) => ((0, index_1.HasTransform)(schema, references) ? (0, index_1.TransformDecode)(schema, references, value) : value),
+exports.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 ((0, index_8.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 */
 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 ? (0, index_8.IsArray)(args[0]) ? [args[0], args[1], [], args[2]] : [exports.ParseDefault, args[0], args[1], args[2]] :
+            args.length === 2 ? [exports.ParseDefault, args[0], [], args[1]] :
+                (() => { throw new ParseError('Invalid Arguments'); })());
+    return ParseValue(operations, schema, references, value);
 }

package/build/esm/compiler/compiler.d.mts

@@ -12,6 +12,10 @@ export declare class TypeCheck<T extends TSchema> {
     constructor(schema: T, references: TSchema[], checkFunc: CheckFunction, code: string);
     /** Returns the generated assertion code used to validate this type. */
     Code(): string;
+    /** Returns the schema type used to validate */
+    Schema(): T;
+    /** Returns reference types used to validate */
+    References(): TSchema[];
     /** Returns an iterator for each error in this value. */
     Errors(value: unknown): ValueErrorIterator;
     /** Returns true if the value matches the compiled type. */

package/build/esm/compiler/compiler.mjs

@@ -32,6 +32,14 @@ export class TypeCheck {
     Code() {
         return this.code;
     }
+    /** Returns the schema type used to validate */
+    Schema() {
+        return this.schema;
+    }
+    /** Returns reference types used to validate */
+    References() {
+        return this.references;
+    }
     /** Returns an iterator for each error in this value. */
     Errors(value) {
         return Errors(this.schema, this.references, value);

package/build/esm/syntax/runtime.d.mts

@@ -48,7 +48,7 @@ export declare const Module: Runtime.Module<{
     Iterator: Runtime.ITuple<Types.TIterator<Types.TSchema>>;
     Awaited: Runtime.ITuple<Types.TSchema>;
     Array: Runtime.ITuple<Types.TArray<Types.TSchema>>;
-    Record: Runtime.ITuple<Types.TSchema>;
+    Record: Runtime.ITuple<Types.TNever>;
     Promise: Runtime.ITuple<Types.TPromise<Types.TSchema>>;
     ConstructorParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
     FunctionParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;

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

@@ -5,8 +5,7 @@ import { Index } from './index.mjs';
 function FromProperties(type, properties, options) {
     const result = {};
     for (const K2 of Object.getOwnPropertyNames(properties)) {
-        const keys = IndexPropertyKeys(properties[K2]);
-        result[K2] = Index(type, keys, options);
+        result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
     }
     return result;
 }