@sinclair/typebox 0.34.3 → 0.34.5

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.TNever>;
+    Record: Runtime.ITuple<Types.TSchema>;
     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/module/compute.d.ts

@@ -6,6 +6,7 @@ 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 TFunction } from '../function/index';
 import { type TIntersect, type TIntersectEvaluated } from '../intersect/index';
 import { type TIterator } from '../iterator/index';
@@ -43,7 +44,7 @@ type TFromArray<ModuleProperties extends TProperties, Type extends TSchema> = (E
 type TFromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TAsyncIterator<TFromType<ModuleProperties, Type>>);
 type TFromIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TIterator<TFromType<ModuleProperties, Type>>);
 type TFromRest<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
-export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TComputed<infer T extends string, infer S extends TSchema[]> ? TFromComputed<ModuleProperties, T, S> : Type extends TObject<infer S extends TProperties> ? TFromObject<ModuleProperties, S> : Type extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TFromConstructor<ModuleProperties, S, R> : Type extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFromFunction<ModuleProperties, S, R> : Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<ModuleProperties, S> : Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<ModuleProperties, S> : Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<ModuleProperties, S> : Type extends TArray<infer S extends TSchema> ? TFromArray<ModuleProperties, S> : Type extends TAsyncIterator<infer S extends TSchema> ? TFromAsyncIterator<ModuleProperties, S> : Type extends TIterator<infer S extends TSchema> ? TFromIterator<ModuleProperties, S> : Type);
+export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<ModuleProperties, Type> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<ModuleProperties, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<ModuleProperties, Properties> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Type : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<ModuleProperties, Types> : Type);
 export declare function FromType<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromType<ModuleProperties, Type>;
 export type TComputeType<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TFromType<ModuleProperties, ModuleProperties[Key]> : TNever);
 export declare function ComputeType<ModuleProperties extends TProperties, Key extends PropertyKey>(moduleProperties: ModuleProperties, key: Key): TComputeType<ModuleProperties, Key>;

package/build/cjs/type/module/compute.js

@@ -124,20 +124,19 @@ function FromRest(moduleProperties, types) {
 }
 // prettier-ignore
 function FromType(moduleProperties, type) {
-    return (
-    // 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.IsObject(type) ? (0, index_1.CreateType)(FromObject(moduleProperties, type.properties), type) :
-            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) :
-                    KindGuard.IsTuple(type) ? (0, index_1.CreateType)(FromTuple(moduleProperties, type.items || []), type) :
+    return (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) :
                         KindGuard.IsIntersect(type) ? (0, index_1.CreateType)(FromIntersect(moduleProperties, type.allOf), type) :
-                            KindGuard.IsUnion(type) ? (0, index_1.CreateType)(FromUnion(moduleProperties, type.anyOf), type) :
-                                KindGuard.IsArray(type) ? (0, index_1.CreateType)(FromArray(moduleProperties, type.items), type) :
-                                    KindGuard.IsAsyncIterator(type) ? (0, index_1.CreateType)(FromAsyncIterator(moduleProperties, type.items), type) :
-                                        KindGuard.IsIterator(type) ? (0, index_1.CreateType)(FromIterator(moduleProperties, type.items), type) :
+                            KindGuard.IsIterator(type) ? (0, index_1.CreateType)(FromIterator(moduleProperties, type.items), type) :
+                                KindGuard.IsObject(type) ? (0, index_1.CreateType)(FromObject(moduleProperties, type.properties), type) :
+                                    KindGuard.IsTuple(type) ? (0, index_1.CreateType)(FromTuple(moduleProperties, type.items || []), type) :
+                                        KindGuard.IsUnion(type) ? (0, index_1.CreateType)(FromUnion(moduleProperties, type.anyOf), type) :
                                             type);
 }
 // prettier-ignore

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

@@ -3,11 +3,13 @@ import { TSchema } from '../schema/index';
 import { TArray } from '../array/index';
 import { TAsyncIterator } from '../async-iterator/index';
 import { TConstructor } from '../constructor/index';
+import { TEnum, TEnumRecord } from '../enum/index';
 import { TFunction } from '../function/index';
 import { TIntersect } from '../intersect/index';
 import { TIterator } from '../iterator/index';
 import { TObject, TProperties } from '../object/index';
 import { TOptional } from '../optional/index';
+import { TRecord } from '../record/index';
 import { TReadonly } from '../readonly/index';
 import { TRef } from '../ref/index';
 import { TTuple } from '../tuple/index';
@@ -18,15 +20,15 @@ type TInferAsyncIterator<ModuleProperties extends TProperties, Type extends TSch
 type TInferConstructor<ModuleProperties extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema> = Ensure<new (...args: TInferTuple<ModuleProperties, Parameters>) => TInfer<ModuleProperties, InstanceType>>;
 type TInferFunction<ModuleProperties extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema> = Ensure<(...args: TInferTuple<ModuleProperties, Parameters>) => TInfer<ModuleProperties, ReturnType>>;
 type TInferIterator<ModuleProperties extends TProperties, Type extends TSchema> = (Ensure<IterableIterator<TInfer<ModuleProperties, Type>>>);
-type TInferIntersect<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferIntersect<ModuleProperties, R, Result & TInfer<ModuleProperties, L>> : Result);
+type TInferIntersect<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TInferIntersect<ModuleProperties, Right, Result & TInfer<ModuleProperties, Left>> : Result);
 type ReadonlyOptionalPropertyKeys<Properties extends TProperties> = {
-    [K in keyof Properties]: Properties[K] extends TReadonly<TSchema> ? (Properties[K] extends TOptional<Properties[K]> ? K : never) : never;
+    [Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? Key : never) : never;
 }[keyof Properties];
 type ReadonlyPropertyKeys<Source extends TProperties> = {
-    [K in keyof Source]: Source[K] extends TReadonly<TSchema> ? (Source[K] extends TOptional<Source[K]> ? never : K) : never;
+    [Key in keyof Source]: Source[Key] extends TReadonly<TSchema> ? (Source[Key] extends TOptional<Source[Key]> ? never : Key) : never;
 }[keyof Source];
 type OptionalPropertyKeys<Source extends TProperties> = {
-    [K in keyof Source]: Source[K] extends TOptional<TSchema> ? (Source[K] extends TReadonly<Source[K]> ? never : K) : never;
+    [Key in keyof Source]: Source[Key] extends TOptional<TSchema> ? (Source[Key] extends TReadonly<Source[Key]> ? never : Key) : never;
 }[keyof Source];
 type RequiredPropertyKeys<Source extends TProperties> = keyof Omit<Source, ReadonlyOptionalPropertyKeys<Source> | ReadonlyPropertyKeys<Source> | OptionalPropertyKeys<Source>>;
 type InferPropertiesWithModifiers<Properties extends TProperties, Source extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<Source, ReadonlyOptionalPropertyKeys<Properties>>>> & Readonly<Pick<Source, ReadonlyPropertyKeys<Properties>>> & Partial<Pick<Source, OptionalPropertyKeys<Properties>>> & Required<Pick<Source, RequiredPropertyKeys<Properties>>>)>;
@@ -35,9 +37,10 @@ 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 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 TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> : Static<Type>);
+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>);
 /** Inference Path for Imports. This type is used to compute TImport `static` */
 export type TInferFromModuleKey<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Key]> : never);
 export {};

package/build/cjs/type/module/module.js

@@ -21,7 +21,8 @@ class TModule {
     }
     /** `[Json]` Imports a Type by Key. */
     Import(key, options) {
-        return (0, index_1.CreateType)({ [index_2.Kind]: 'Import', $defs: this.$defs, $ref: key }, options);
+        const $defs = { ...this.$defs, [key]: (0, index_1.CreateType)(this.$defs[key], options) };
+        return (0, index_1.CreateType)({ [index_2.Kind]: 'Import', $defs, $ref: key });
     }
     // prettier-ignore
     WithIdentifiers($defs) {

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

@@ -1,58 +1,58 @@
+import { Kind } from '../symbols/index';
 import type { TSchema } from '../schema/index';
 import type { Static } from '../static/index';
 import type { Evaluate, Ensure, Assert } from '../helpers/index';
 import { type TAny } from '../any/index';
 import { type TComputed } from '../computed/index';
-import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index';
+import { type TEnumRecord, type TEnum } from '../enum/index';
+import { type TInteger } from '../integer/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TNever } from '../never/index';
-import { type TUnion } from '../union/index';
-import { type TRegExp } from '../regexp/index';
-import { type TString } from '../string/index';
-import { type TInteger } from '../integer/index';
 import { type TNumber } from '../number/index';
-import { type TEnum } from '../enum/index';
+import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index';
 import { type TRef } from '../ref/index';
+import { type TRegExp } from '../regexp/index';
+import { type TString } from '../string/index';
+import { type TUnion } from '../union/index';
 import { TIsTemplateLiteralFinite, type TTemplateLiteral } from '../template-literal/index';
-import { Kind } from '../symbols/index';
-type TFromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>;
-type TFromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I extends string = Static<K>> = (Ensure<TObject<Evaluate<{
-    [_ in I]: T;
+type TFromTemplateLiteralKeyInfinite<Key extends TTemplateLiteral, Type extends TSchema> = Ensure<TRecord<Key, Type>>;
+type TFromTemplateLiteralKeyFinite<Key extends TTemplateLiteral, Type extends TSchema, I extends string = Static<Key>> = (Ensure<TObject<Evaluate<{
+    [_ in I]: Type;
 }>>>);
-type TFromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = TIsTemplateLiteralFinite<K> extends false ? TFromTemplateLiteralKeyInfinite<K, T> : TFromTemplateLiteralKeyFinite<K, T>;
-type TFromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{
-    [_ in K[keyof K]]: T;
+type TFromTemplateLiteralKey<Key extends TTemplateLiteral, Type extends TSchema> = TIsTemplateLiteralFinite<Key> extends false ? TFromTemplateLiteralKeyInfinite<Key, Type> : TFromTemplateLiteralKeyFinite<Key, Type>;
+type TFromEnumKey<Key extends Record<string, string | number>, Type extends TSchema> = Ensure<TObject<{
+    [_ in Key[keyof Key]]: Type;
 }>>;
-type TFromUnionKeyLiteralString<K extends TLiteral<string>, T extends TSchema> = {
-    [_ in K['const']]: T;
+type TFromUnionKeyLiteralString<Key extends TLiteral<string>, Type extends TSchema> = {
+    [_ in Key['const']]: Type;
 };
-type TFromUnionKeyLiteralNumber<K extends TLiteral<number>, T extends TSchema> = {
-    [_ in K['const']]: T;
+type TFromUnionKeyLiteralNumber<Key extends TLiteral<number>, Type extends TSchema> = {
+    [_ in Key['const']]: Type;
 };
-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<Evaluate<P>>>);
-type TFromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObject<{
-    [_ in Assert<K, PropertyKey>]: T;
+type TFromUnionKeyRest<Keys extends TSchema[], Type extends TSchema> = Keys extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? (Left extends TUnion<infer Types extends TSchema[]> ? TFromUnionKeyRest<Types, Type> & TFromUnionKeyRest<Right, Type> : Left extends TLiteral<string> ? TFromUnionKeyLiteralString<Left, Type> & TFromUnionKeyRest<Right, Type> : Left extends TLiteral<number> ? TFromUnionKeyLiteralNumber<Left, Type> & TFromUnionKeyRest<Right, Type> : {}) : {};
+type TFromUnionKey<Key extends TSchema[], Type extends TSchema, P extends TProperties = TFromUnionKeyRest<Key, Type>> = (Ensure<TObject<Evaluate<P>>>);
+type TFromLiteralKey<Key extends TLiteralValue, Type extends TSchema> = (Ensure<TObject<{
+    [_ in Assert<Key, PropertyKey>]: Type;
 }>>);
-type TFromRegExpKey<_ extends TRegExp, T extends TSchema> = (Ensure<TRecord<TRegExp, T>>);
-type TFromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
-type TFromAnyKey<_ extends TAny, T extends TSchema> = (Ensure<TRecord<TAny, T>>);
-type TFromNeverKey<_ extends TNever, T extends TSchema> = (Ensure<TRecord<TNever, T>>);
-type TFromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
-type TFromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
-type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (Evaluate<{
-    [_ in Assert<Static<K>, PropertyKey>]: Static<T, P>;
+type TFromRegExpKey<_Key extends TRegExp, Type extends TSchema> = (Ensure<TRecord<TRegExp, Type>>);
+type TFromStringKey<_Key extends TString, Type extends TSchema> = (Ensure<TRecord<TString, Type>>);
+type TFromAnyKey<_Key extends TAny, Type extends TSchema> = (Ensure<TRecord<TAny, Type>>);
+type TFromNeverKey<_Key extends TNever, Type extends TSchema> = (Ensure<TRecord<TNever, Type>>);
+type TFromIntegerKey<_Key extends TSchema, Type extends TSchema> = (Ensure<TRecord<TNumber, Type>>);
+type TFromNumberKey<_Key extends TSchema, Type extends TSchema> = (Ensure<TRecord<TNumber, Type>>);
+type RecordStatic<Key extends TSchema, Type extends TSchema, P extends unknown[]> = (Evaluate<{
+    [_ in Assert<Static<Key>, PropertyKey>]: Static<Type, P>;
 }>);
-export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
+export interface TRecord<Key extends TSchema = TSchema, Type extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Record';
-    static: RecordStatic<K, T, this['params']>;
+    static: RecordStatic<Key, Type, this['params']>;
     type: 'object';
     patternProperties: {
-        [pattern: string]: T;
+        [pattern: string]: Type;
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = Type extends TRef ? TComputed<'Record', [Key, Type]> : Key extends TRef ? TComputed<'Record', [Key, Type]> : Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer S> ? TFromEnumKey<S, Type> : Key extends TUnion<infer S> ? TFromUnionKey<S, Type> : Key extends TLiteral<infer S> ? TFromLiteralKey<S, 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;
+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);
 /** `[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/record/record.js

@@ -3,14 +3,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Record = Record;
 const type_1 = require("../create/type");
-const index_1 = require("../computed/index");
-const index_2 = require("../object/index");
+const index_1 = require("../symbols/index");
+const index_2 = require("../computed/index");
 const index_3 = require("../never/index");
-const index_4 = require("../union/index");
-const index_5 = require("../template-literal/index");
-const index_6 = require("../patterns/index");
-const index_7 = require("../indexed/index");
-const index_8 = require("../symbols/index");
+const index_4 = require("../object/index");
+const index_5 = require("../ref/index");
+const index_6 = require("../union/index");
+const index_7 = require("../template-literal/index");
+const index_8 = require("../patterns/index");
+const index_9 = require("../indexed/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -24,60 +25,56 @@ const kind_1 = require("../guard/kind");
 // ------------------------------------------------------------------
 // prettier-ignore
 function RecordCreateFromPattern(pattern, T, options) {
-    return (0, type_1.CreateType)({
-        [index_8.Kind]: 'Record',
-        type: 'object',
-        patternProperties: { [pattern]: T }
-    }, options);
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: T } }, options);
 }
 // ------------------------------------------------------------------
 // RecordCreateFromKeys
 // ------------------------------------------------------------------
 // prettier-ignore
 function RecordCreateFromKeys(K, T, options) {
-    const Acc = {};
+    const result = {};
     for (const K2 of K)
-        Acc[K2] = T;
-    return (0, index_2.Object)(Acc, { ...options, [index_8.Hint]: 'Record' });
+        result[K2] = T;
+    return (0, index_4.Object)(result, { ...options, [index_1.Hint]: 'Record' });
 }
 // prettier-ignore
 function FromTemplateLiteralKey(K, T, options) {
-    return ((0, index_5.IsTemplateLiteralFinite)(K)
-        ? RecordCreateFromKeys((0, index_7.IndexPropertyKeys)(K), T, options)
+    return ((0, index_7.IsTemplateLiteralFinite)(K)
+        ? RecordCreateFromKeys((0, index_9.IndexPropertyKeys)(K), T, options)
         : RecordCreateFromPattern(K.pattern, T, options));
 }
 // prettier-ignore
-function FromUnionKey(K, T, options) {
-    return RecordCreateFromKeys((0, index_7.IndexPropertyKeys)((0, index_4.Union)(K)), T, options);
+function FromUnionKey(key, type, options) {
+    return RecordCreateFromKeys((0, index_9.IndexPropertyKeys)((0, index_6.Union)(key)), type, options);
 }
 // prettier-ignore
-function FromLiteralKey(K, T, options) {
-    return RecordCreateFromKeys([K.toString()], T, options);
+function FromLiteralKey(key, type, options) {
+    return RecordCreateFromKeys([key.toString()], type, options);
 }
 // prettier-ignore
-function FromRegExpKey(K, T, options) {
-    return RecordCreateFromPattern(K.source, T, options);
+function FromRegExpKey(key, type, options) {
+    return RecordCreateFromPattern(key.source, type, options);
 }
 // prettier-ignore
-function FromStringKey(K, T, options) {
-    const pattern = (0, value_1.IsUndefined)(K.pattern) ? index_6.PatternStringExact : K.pattern;
-    return RecordCreateFromPattern(pattern, T, options);
+function FromStringKey(key, type, options) {
+    const pattern = (0, value_1.IsUndefined)(key.pattern) ? index_8.PatternStringExact : key.pattern;
+    return RecordCreateFromPattern(pattern, type, options);
 }
 // prettier-ignore
-function FromAnyKey(K, T, options) {
-    return RecordCreateFromPattern(index_6.PatternStringExact, T, options);
+function FromAnyKey(_, type, options) {
+    return RecordCreateFromPattern(index_8.PatternStringExact, type, options);
 }
 // prettier-ignore
-function FromNeverKey(K, T, options) {
-    return RecordCreateFromPattern(index_6.PatternNeverExact, T, options);
+function FromNeverKey(_key, type, options) {
+    return RecordCreateFromPattern(index_8.PatternNeverExact, type, options);
 }
 // prettier-ignore
-function FromIntegerKey(_, T, options) {
-    return RecordCreateFromPattern(index_6.PatternNumberExact, T, options);
+function FromIntegerKey(_key, type, options) {
+    return RecordCreateFromPattern(index_8.PatternNumberExact, type, options);
 }
 // prettier-ignore
-function FromNumberKey(_, T, options) {
-    return RecordCreateFromPattern(index_6.PatternNumberExact, T, options);
+function FromNumberKey(_, type, options) {
+    return RecordCreateFromPattern(index_8.PatternNumberExact, type, options);
 }
 // ------------------------------------------------------------------
 // TRecordOrObject
@@ -85,16 +82,17 @@ function FromNumberKey(_, T, options) {
 /** `[Json]` Creates a Record type */
 function Record(key, type, options = {}) {
     // prettier-ignore
-    return ((0, kind_1.IsRef)(type) ? (0, index_1.Computed)('Record', [key, type]) :
-        (0, kind_1.IsRef)(key) ? (0, index_1.Computed)('Record', [key, type]) :
-            (0, kind_1.IsUnion)(key) ? FromUnionKey(key.anyOf, type, options) :
-                (0, kind_1.IsTemplateLiteral)(key) ? FromTemplateLiteralKey(key, type, options) :
-                    (0, kind_1.IsLiteral)(key) ? FromLiteralKey(key.const, type, options) :
-                        (0, kind_1.IsInteger)(key) ? FromIntegerKey(key, type, options) :
-                            (0, kind_1.IsNumber)(key) ? FromNumberKey(key, type, options) :
-                                (0, kind_1.IsRegExp)(key) ? FromRegExpKey(key, type, options) :
-                                    (0, kind_1.IsString)(key) ? FromStringKey(key, type, options) :
-                                        (0, kind_1.IsAny)(key) ? FromAnyKey(key, type, options) :
-                                            (0, kind_1.IsNever)(key) ? FromNeverKey(key, type, options) :
-                                                (0, index_3.Never)(options));
+    return ((0, kind_1.IsComputed)(type) ? (0, index_2.Computed)('Record', [key, (0, index_2.Computed)(type.target, type.parameters)], options) :
+        (0, kind_1.IsComputed)(key) ? (0, index_2.Computed)('Record', [(0, index_2.Computed)(type.target, type.parameters), type], options) :
+            (0, kind_1.IsRef)(key) ? (0, index_2.Computed)('Record', [(0, index_5.Ref)(key.$ref), type]) :
+                (0, kind_1.IsUnion)(key) ? FromUnionKey(key.anyOf, type, options) :
+                    (0, kind_1.IsTemplateLiteral)(key) ? FromTemplateLiteralKey(key, type, options) :
+                        (0, kind_1.IsLiteral)(key) ? FromLiteralKey(key.const, type, options) :
+                            (0, kind_1.IsInteger)(key) ? FromIntegerKey(key, type, options) :
+                                (0, kind_1.IsNumber)(key) ? FromNumberKey(key, type, options) :
+                                    (0, kind_1.IsRegExp)(key) ? FromRegExpKey(key, type, options) :
+                                        (0, kind_1.IsString)(key) ? FromStringKey(key, type, options) :
+                                            (0, kind_1.IsAny)(key) ? FromAnyKey(key, type, options) :
+                                                (0, kind_1.IsNever)(key) ? FromNeverKey(key, type, options) :
+                                                    (0, index_3.Never)(options));
 }

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.TNever>;
+    Record: Runtime.ITuple<Types.TSchema>;
     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/module/compute.d.mts

@@ -6,6 +6,7 @@ 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 TFunction } from '../function/index.mjs';
 import { type TIntersect, type TIntersectEvaluated } from '../intersect/index.mjs';
 import { type TIterator } from '../iterator/index.mjs';
@@ -43,7 +44,7 @@ type TFromArray<ModuleProperties extends TProperties, Type extends TSchema> = (E
 type TFromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TAsyncIterator<TFromType<ModuleProperties, Type>>);
 type TFromIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TIterator<TFromType<ModuleProperties, Type>>);
 type TFromRest<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
-export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TComputed<infer T extends string, infer S extends TSchema[]> ? TFromComputed<ModuleProperties, T, S> : Type extends TObject<infer S extends TProperties> ? TFromObject<ModuleProperties, S> : Type extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TFromConstructor<ModuleProperties, S, R> : Type extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFromFunction<ModuleProperties, S, R> : Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<ModuleProperties, S> : Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<ModuleProperties, S> : Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<ModuleProperties, S> : Type extends TArray<infer S extends TSchema> ? TFromArray<ModuleProperties, S> : Type extends TAsyncIterator<infer S extends TSchema> ? TFromAsyncIterator<ModuleProperties, S> : Type extends TIterator<infer S extends TSchema> ? TFromIterator<ModuleProperties, S> : Type);
+export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<ModuleProperties, Type> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<ModuleProperties, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<ModuleProperties, Properties> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Type : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<ModuleProperties, Types> : Type);
 export declare function FromType<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromType<ModuleProperties, Type>;
 export type TComputeType<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TFromType<ModuleProperties, ModuleProperties[Key]> : TNever);
 export declare function ComputeType<ModuleProperties extends TProperties, Key extends PropertyKey>(moduleProperties: ModuleProperties, key: Key): TComputeType<ModuleProperties, Key>;

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

@@ -118,20 +118,19 @@ function FromRest(moduleProperties, types) {
 }
 // prettier-ignore
 export function FromType(moduleProperties, type) {
-    return (
-    // 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.IsObject(type) ? CreateType(FromObject(moduleProperties, type.properties), type) :
-            KindGuard.IsConstructor(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
-                KindGuard.IsFunction(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) :
-                    KindGuard.IsTuple(type) ? CreateType(FromTuple(moduleProperties, type.items || []), type) :
+    return (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) :
                         KindGuard.IsIntersect(type) ? CreateType(FromIntersect(moduleProperties, type.allOf), type) :
-                            KindGuard.IsUnion(type) ? CreateType(FromUnion(moduleProperties, type.anyOf), type) :
-                                KindGuard.IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) :
-                                    KindGuard.IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) :
-                                        KindGuard.IsIterator(type) ? CreateType(FromIterator(moduleProperties, type.items), type) :
+                            KindGuard.IsIterator(type) ? CreateType(FromIterator(moduleProperties, type.items), type) :
+                                KindGuard.IsObject(type) ? CreateType(FromObject(moduleProperties, type.properties), type) :
+                                    KindGuard.IsTuple(type) ? CreateType(FromTuple(moduleProperties, type.items || []), type) :
+                                        KindGuard.IsUnion(type) ? CreateType(FromUnion(moduleProperties, type.anyOf), type) :
                                             type);
 }
 // prettier-ignore

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

@@ -3,11 +3,13 @@ import { TSchema } from '../schema/index.mjs';
 import { TArray } from '../array/index.mjs';
 import { TAsyncIterator } from '../async-iterator/index.mjs';
 import { TConstructor } from '../constructor/index.mjs';
+import { TEnum, TEnumRecord } from '../enum/index.mjs';
 import { TFunction } from '../function/index.mjs';
 import { TIntersect } from '../intersect/index.mjs';
 import { TIterator } from '../iterator/index.mjs';
 import { TObject, TProperties } from '../object/index.mjs';
 import { TOptional } from '../optional/index.mjs';
+import { TRecord } from '../record/index.mjs';
 import { TReadonly } from '../readonly/index.mjs';
 import { TRef } from '../ref/index.mjs';
 import { TTuple } from '../tuple/index.mjs';
@@ -18,15 +20,15 @@ type TInferAsyncIterator<ModuleProperties extends TProperties, Type extends TSch
 type TInferConstructor<ModuleProperties extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema> = Ensure<new (...args: TInferTuple<ModuleProperties, Parameters>) => TInfer<ModuleProperties, InstanceType>>;
 type TInferFunction<ModuleProperties extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema> = Ensure<(...args: TInferTuple<ModuleProperties, Parameters>) => TInfer<ModuleProperties, ReturnType>>;
 type TInferIterator<ModuleProperties extends TProperties, Type extends TSchema> = (Ensure<IterableIterator<TInfer<ModuleProperties, Type>>>);
-type TInferIntersect<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferIntersect<ModuleProperties, R, Result & TInfer<ModuleProperties, L>> : Result);
+type TInferIntersect<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TInferIntersect<ModuleProperties, Right, Result & TInfer<ModuleProperties, Left>> : Result);
 type ReadonlyOptionalPropertyKeys<Properties extends TProperties> = {
-    [K in keyof Properties]: Properties[K] extends TReadonly<TSchema> ? (Properties[K] extends TOptional<Properties[K]> ? K : never) : never;
+    [Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? Key : never) : never;
 }[keyof Properties];
 type ReadonlyPropertyKeys<Source extends TProperties> = {
-    [K in keyof Source]: Source[K] extends TReadonly<TSchema> ? (Source[K] extends TOptional<Source[K]> ? never : K) : never;
+    [Key in keyof Source]: Source[Key] extends TReadonly<TSchema> ? (Source[Key] extends TOptional<Source[Key]> ? never : Key) : never;
 }[keyof Source];
 type OptionalPropertyKeys<Source extends TProperties> = {
-    [K in keyof Source]: Source[K] extends TOptional<TSchema> ? (Source[K] extends TReadonly<Source[K]> ? never : K) : never;
+    [Key in keyof Source]: Source[Key] extends TOptional<TSchema> ? (Source[Key] extends TReadonly<Source[Key]> ? never : Key) : never;
 }[keyof Source];
 type RequiredPropertyKeys<Source extends TProperties> = keyof Omit<Source, ReadonlyOptionalPropertyKeys<Source> | ReadonlyPropertyKeys<Source> | OptionalPropertyKeys<Source>>;
 type InferPropertiesWithModifiers<Properties extends TProperties, Source extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<Source, ReadonlyOptionalPropertyKeys<Properties>>>> & Readonly<Pick<Source, ReadonlyPropertyKeys<Properties>>> & Partial<Pick<Source, OptionalPropertyKeys<Properties>>> & Required<Pick<Source, RequiredPropertyKeys<Properties>>>)>;
@@ -35,9 +37,10 @@ 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 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 TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> : Static<Type>);
+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>);
 /** Inference Path for Imports. This type is used to compute TImport `static` */
 export type TInferFromModuleKey<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Key]> : never);
 export {};

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

@@ -16,7 +16,8 @@ export class TModule {
     }
     /** `[Json]` Imports a Type by Key. */
     Import(key, options) {
-        return CreateType({ [Kind]: 'Import', $defs: this.$defs, $ref: key }, options);
+        const $defs = { ...this.$defs, [key]: CreateType(this.$defs[key], options) };
+        return CreateType({ [Kind]: 'Import', $defs, $ref: key });
     }
     // prettier-ignore
     WithIdentifiers($defs) {

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

@@ -1,58 +1,58 @@
+import { Kind } from '../symbols/index.mjs';
 import type { TSchema } from '../schema/index.mjs';
 import type { Static } from '../static/index.mjs';
 import type { Evaluate, Ensure, Assert } from '../helpers/index.mjs';
 import { type TAny } from '../any/index.mjs';
 import { type TComputed } from '../computed/index.mjs';
-import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index.mjs';
+import { type TEnumRecord, type TEnum } from '../enum/index.mjs';
+import { type TInteger } from '../integer/index.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TNever } from '../never/index.mjs';
-import { type TUnion } from '../union/index.mjs';
-import { type TRegExp } from '../regexp/index.mjs';
-import { type TString } from '../string/index.mjs';
-import { type TInteger } from '../integer/index.mjs';
 import { type TNumber } from '../number/index.mjs';
-import { type TEnum } from '../enum/index.mjs';
+import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index.mjs';
 import { type TRef } from '../ref/index.mjs';
+import { type TRegExp } from '../regexp/index.mjs';
+import { type TString } from '../string/index.mjs';
+import { type TUnion } from '../union/index.mjs';
 import { TIsTemplateLiteralFinite, type TTemplateLiteral } from '../template-literal/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-type TFromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>;
-type TFromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I extends string = Static<K>> = (Ensure<TObject<Evaluate<{
-    [_ in I]: T;
+type TFromTemplateLiteralKeyInfinite<Key extends TTemplateLiteral, Type extends TSchema> = Ensure<TRecord<Key, Type>>;
+type TFromTemplateLiteralKeyFinite<Key extends TTemplateLiteral, Type extends TSchema, I extends string = Static<Key>> = (Ensure<TObject<Evaluate<{
+    [_ in I]: Type;
 }>>>);
-type TFromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = TIsTemplateLiteralFinite<K> extends false ? TFromTemplateLiteralKeyInfinite<K, T> : TFromTemplateLiteralKeyFinite<K, T>;
-type TFromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{
-    [_ in K[keyof K]]: T;
+type TFromTemplateLiteralKey<Key extends TTemplateLiteral, Type extends TSchema> = TIsTemplateLiteralFinite<Key> extends false ? TFromTemplateLiteralKeyInfinite<Key, Type> : TFromTemplateLiteralKeyFinite<Key, Type>;
+type TFromEnumKey<Key extends Record<string, string | number>, Type extends TSchema> = Ensure<TObject<{
+    [_ in Key[keyof Key]]: Type;
 }>>;
-type TFromUnionKeyLiteralString<K extends TLiteral<string>, T extends TSchema> = {
-    [_ in K['const']]: T;
+type TFromUnionKeyLiteralString<Key extends TLiteral<string>, Type extends TSchema> = {
+    [_ in Key['const']]: Type;
 };
-type TFromUnionKeyLiteralNumber<K extends TLiteral<number>, T extends TSchema> = {
-    [_ in K['const']]: T;
+type TFromUnionKeyLiteralNumber<Key extends TLiteral<number>, Type extends TSchema> = {
+    [_ in Key['const']]: Type;
 };
-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<Evaluate<P>>>);
-type TFromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObject<{
-    [_ in Assert<K, PropertyKey>]: T;
+type TFromUnionKeyRest<Keys extends TSchema[], Type extends TSchema> = Keys extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? (Left extends TUnion<infer Types extends TSchema[]> ? TFromUnionKeyRest<Types, Type> & TFromUnionKeyRest<Right, Type> : Left extends TLiteral<string> ? TFromUnionKeyLiteralString<Left, Type> & TFromUnionKeyRest<Right, Type> : Left extends TLiteral<number> ? TFromUnionKeyLiteralNumber<Left, Type> & TFromUnionKeyRest<Right, Type> : {}) : {};
+type TFromUnionKey<Key extends TSchema[], Type extends TSchema, P extends TProperties = TFromUnionKeyRest<Key, Type>> = (Ensure<TObject<Evaluate<P>>>);
+type TFromLiteralKey<Key extends TLiteralValue, Type extends TSchema> = (Ensure<TObject<{
+    [_ in Assert<Key, PropertyKey>]: Type;
 }>>);
-type TFromRegExpKey<_ extends TRegExp, T extends TSchema> = (Ensure<TRecord<TRegExp, T>>);
-type TFromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
-type TFromAnyKey<_ extends TAny, T extends TSchema> = (Ensure<TRecord<TAny, T>>);
-type TFromNeverKey<_ extends TNever, T extends TSchema> = (Ensure<TRecord<TNever, T>>);
-type TFromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
-type TFromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
-type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (Evaluate<{
-    [_ in Assert<Static<K>, PropertyKey>]: Static<T, P>;
+type TFromRegExpKey<_Key extends TRegExp, Type extends TSchema> = (Ensure<TRecord<TRegExp, Type>>);
+type TFromStringKey<_Key extends TString, Type extends TSchema> = (Ensure<TRecord<TString, Type>>);
+type TFromAnyKey<_Key extends TAny, Type extends TSchema> = (Ensure<TRecord<TAny, Type>>);
+type TFromNeverKey<_Key extends TNever, Type extends TSchema> = (Ensure<TRecord<TNever, Type>>);
+type TFromIntegerKey<_Key extends TSchema, Type extends TSchema> = (Ensure<TRecord<TNumber, Type>>);
+type TFromNumberKey<_Key extends TSchema, Type extends TSchema> = (Ensure<TRecord<TNumber, Type>>);
+type RecordStatic<Key extends TSchema, Type extends TSchema, P extends unknown[]> = (Evaluate<{
+    [_ in Assert<Static<Key>, PropertyKey>]: Static<Type, P>;
 }>);
-export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
+export interface TRecord<Key extends TSchema = TSchema, Type extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Record';
-    static: RecordStatic<K, T, this['params']>;
+    static: RecordStatic<Key, Type, this['params']>;
     type: 'object';
     patternProperties: {
-        [pattern: string]: T;
+        [pattern: string]: Type;
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = Type extends TRef ? TComputed<'Record', [Key, Type]> : Key extends TRef ? TComputed<'Record', [Key, Type]> : Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer S> ? TFromEnumKey<S, Type> : Key extends TUnion<infer S> ? TFromUnionKey<S, Type> : Key extends TLiteral<infer S> ? TFromLiteralKey<S, 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;
+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);
 /** `[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/record/record.mjs

@@ -1,12 +1,13 @@
 import { CreateType } from '../create/type.mjs';
+import { Kind, Hint } from '../symbols/index.mjs';
 import { Computed } from '../computed/index.mjs';
-import { Object } from '../object/index.mjs';
 import { Never } from '../never/index.mjs';
+import { Object } from '../object/index.mjs';
+import { Ref } from '../ref/index.mjs';
 import { Union } from '../union/index.mjs';
 import { IsTemplateLiteralFinite } from '../template-literal/index.mjs';
 import { PatternStringExact, PatternNumberExact, PatternNeverExact } from '../patterns/index.mjs';
 import { IndexPropertyKeys } from '../indexed/index.mjs';
-import { Kind, Hint } from '../symbols/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -14,27 +15,23 @@ import { IsUndefined } from '../guard/value.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion, IsRef } from '../guard/kind.mjs';
+import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion, IsRef, IsComputed } from '../guard/kind.mjs';
 // ------------------------------------------------------------------
 // RecordCreateFromPattern
 // ------------------------------------------------------------------
 // prettier-ignore
 function RecordCreateFromPattern(pattern, T, options) {
-    return CreateType({
-        [Kind]: 'Record',
-        type: 'object',
-        patternProperties: { [pattern]: T }
-    }, options);
+    return CreateType({ [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: T } }, options);
 }
 // ------------------------------------------------------------------
 // RecordCreateFromKeys
 // ------------------------------------------------------------------
 // prettier-ignore
 function RecordCreateFromKeys(K, T, options) {
-    const Acc = {};
+    const result = {};
     for (const K2 of K)
-        Acc[K2] = T;
-    return Object(Acc, { ...options, [Hint]: 'Record' });
+        result[K2] = T;
+    return Object(result, { ...options, [Hint]: 'Record' });
 }
 // prettier-ignore
 function FromTemplateLiteralKey(K, T, options) {
@@ -43,37 +40,37 @@ function FromTemplateLiteralKey(K, T, options) {
         : RecordCreateFromPattern(K.pattern, T, options));
 }
 // prettier-ignore
-function FromUnionKey(K, T, options) {
-    return RecordCreateFromKeys(IndexPropertyKeys(Union(K)), T, options);
+function FromUnionKey(key, type, options) {
+    return RecordCreateFromKeys(IndexPropertyKeys(Union(key)), type, options);
 }
 // prettier-ignore
-function FromLiteralKey(K, T, options) {
-    return RecordCreateFromKeys([K.toString()], T, options);
+function FromLiteralKey(key, type, options) {
+    return RecordCreateFromKeys([key.toString()], type, options);
 }
 // prettier-ignore
-function FromRegExpKey(K, T, options) {
-    return RecordCreateFromPattern(K.source, T, options);
+function FromRegExpKey(key, type, options) {
+    return RecordCreateFromPattern(key.source, type, options);
 }
 // prettier-ignore
-function FromStringKey(K, T, options) {
-    const pattern = IsUndefined(K.pattern) ? PatternStringExact : K.pattern;
-    return RecordCreateFromPattern(pattern, T, options);
+function FromStringKey(key, type, options) {
+    const pattern = IsUndefined(key.pattern) ? PatternStringExact : key.pattern;
+    return RecordCreateFromPattern(pattern, type, options);
 }
 // prettier-ignore
-function FromAnyKey(K, T, options) {
-    return RecordCreateFromPattern(PatternStringExact, T, options);
+function FromAnyKey(_, type, options) {
+    return RecordCreateFromPattern(PatternStringExact, type, options);
 }
 // prettier-ignore
-function FromNeverKey(K, T, options) {
-    return RecordCreateFromPattern(PatternNeverExact, T, options);
+function FromNeverKey(_key, type, options) {
+    return RecordCreateFromPattern(PatternNeverExact, type, options);
 }
 // prettier-ignore
-function FromIntegerKey(_, T, options) {
-    return RecordCreateFromPattern(PatternNumberExact, T, options);
+function FromIntegerKey(_key, type, options) {
+    return RecordCreateFromPattern(PatternNumberExact, type, options);
 }
 // prettier-ignore
-function FromNumberKey(_, T, options) {
-    return RecordCreateFromPattern(PatternNumberExact, T, options);
+function FromNumberKey(_, type, options) {
+    return RecordCreateFromPattern(PatternNumberExact, type, options);
 }
 // ------------------------------------------------------------------
 // TRecordOrObject
@@ -81,16 +78,17 @@ function FromNumberKey(_, T, options) {
 /** `[Json]` Creates a Record type */
 export function Record(key, type, options = {}) {
     // prettier-ignore
-    return (IsRef(type) ? Computed('Record', [key, type]) :
-        IsRef(key) ? Computed('Record', [key, type]) :
-            IsUnion(key) ? FromUnionKey(key.anyOf, type, options) :
-                IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) :
-                    IsLiteral(key) ? FromLiteralKey(key.const, type, options) :
-                        IsInteger(key) ? FromIntegerKey(key, type, options) :
-                            IsNumber(key) ? FromNumberKey(key, type, options) :
-                                IsRegExp(key) ? FromRegExpKey(key, type, options) :
-                                    IsString(key) ? FromStringKey(key, type, options) :
-                                        IsAny(key) ? FromAnyKey(key, type, options) :
-                                            IsNever(key) ? FromNeverKey(key, type, options) :
-                                                Never(options));
+    return (IsComputed(type) ? Computed('Record', [key, Computed(type.target, type.parameters)], options) :
+        IsComputed(key) ? Computed('Record', [Computed(type.target, type.parameters), type], options) :
+            IsRef(key) ? Computed('Record', [Ref(key.$ref), type]) :
+                IsUnion(key) ? FromUnionKey(key.anyOf, type, options) :
+                    IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) :
+                        IsLiteral(key) ? FromLiteralKey(key.const, type, options) :
+                            IsInteger(key) ? FromIntegerKey(key, type, options) :
+                                IsNumber(key) ? FromNumberKey(key, type, options) :
+                                    IsRegExp(key) ? FromRegExpKey(key, type, options) :
+                                        IsString(key) ? FromStringKey(key, type, options) :
+                                            IsAny(key) ? FromAnyKey(key, type, options) :
+                                                IsNever(key) ? FromNeverKey(key, type, options) :
+                                                    Never(options));
 }

package/package.json

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

package/readme.md

@@ -774,39 +774,47 @@ type T = Static<typeof T>                            // type T = string | null
 
 ### Module Types
 
-TypeBox Modules are containers for related types. They function as namespaces and enable internal types to reference each other via string references. Modules support both singular and mutually recursive types. They provide a mechanism to create circular types irrespective of the order in which types are defined.
+TypeBox Modules are containers for related types. They provide a referential namespace, enabling types to reference one another via string identifiers. Modules support both singular and mutually recursive referencing within the context of a module, as well as referential computed types (such as Partial + Ref). All Module types must be imported before use. TypeBox represents an imported type with the `$defs` Json Schema keyword. 
 
-```typescript
+#### Usage
+
+The following creates a Module with User and PartialUser types. Note that the PartialUser type is specified as a Partial + Ref to the User type. It is not possible to perform a Partial operation directly on a reference, so TypeBox will return a TComputed type that defers the Partial operation until all types are resolved. The TComputed type is evaluated when calling Import on the Module.
 
-// The following creates a Module of circular recursive Types.
+```typescript
+// Module with PartialUser and User types
 
 const Module = Type.Module({
-  A: Type.Object({ 
-    b: Type.Ref('B') // Ref B:
-  }),
-  B: Type.Object({
-    c: Type.Ref('C') // Ref C:
-  }),
-  C: Type.Object({
-    a: Type.Ref('A') // Ref A:
-  }),
+
+  PartialUser: Type.Partial(Type.Ref('User')),  // TComputed<'Partial', [TRef<'User'>]>
+
+  User: Type.Object({                           // TObject<{
+    id: Type.String(),                          //   user: TString,
+    name: Type.String(),                        //   name: TString,
+    email: Type.String()                        //   email: TString
+  }),                                           // }>
+  
 })
 
-// Module Types must be imported before use.
+// Types must be imported before use.
 
-const A = Module.Import('A')                     // const A: TImport<{...}, 'A'>
+const User = Module.Import('User')               // const User: TImport<{...}, 'User'>
 
-type A = Static<typeof A>                        // type A = { 
-                                                 //   b: {
-                                                 //     c: {
-                                                 //       a: {
-                                                 //         b: ...
-                                                 //       }
-                                                 //     }
-                                                 //   }
+type User = Static<typeof User>                  // type User = { 
+                                                 //   id: string,
+                                                 //   name: string,
+                                                 //   email: string
+                                                 // }
+
+const PartialUser = Module.Import('PartialUser') // const PartialUser: TImport<{...}, 'PartialUser'>
+
+type PartialUser = Static<typeof PartialUser>    // type PartialUser = { 
+                                                 //   id?: string,
+                                                 //   name?: string,
+                                                 //   email?: string
                                                  // }
 ```
 
+
 <a name='types-template-literal'></a>
 
 ### Template Literal Types
@@ -1025,7 +1033,7 @@ if(TypeGuard.IsString(T)) {
 
 ## Syntax Types
 
-TypeBox provides support for Syntax Types, enabling it to parse TypeScript syntax directly into TypeBox types. Syntax Types serve as a DSL frontend for TypeBox's type builder and are useful for converting existing TypeScript type definitions into Json Schema schematics.
+TypeBox provides support for parsing TypeScript syntax directly into TypeBox Json Schema schematics. Syntax Types offer a string based DSL frontend to TypeBox's Type Builder system and can be useful for converting existing TypeScript type definitions into Json Schema schematics without reimplementation via the Type Builder.
 
 Syntax Types are provided via optional import.
 
@@ -1106,14 +1114,14 @@ type PartialUser = Static<typeof PartialUser>       // type PartialUser = {
 
 ### Context
 
-The Parse function accepts an initial Context argument, allowing external types to be passed into the parser.
+The Parse function takes an optional leading Context object that contains external types. This Context allows the syntax to reference these external types using the property identifiers provided by the Context. The following passes the external type `T` to Parse.
 
 ```typescript
-const T = Type.Object({                             // could be written as: Parse(`{
-  x: Type.Number(),                                 //   x: number,
-  y: Type.Number(),                                 //   y: number,
-  z: Type.Number()                                  //   z: number
-})                                                  // }`)
+const T = Type.Object({                             // const T: TObject<{
+  x: Type.Number(),                                 //   x: TNumber,
+  y: Type.Number(),                                 //   y: TNumber,
+  z: Type.Number()                                  //   z: TNumber
+})                                                  // }>
 
 const A = Parse({ T }, 'Partial<T>')                // const A: TObject<{
                                                     //   x: TOptional<TNumber>,
@@ -1140,7 +1148,7 @@ const C = Parse({ T }, 'T & { w: number }')         // const C: TIntersect<[TObj
 
 ### Static
 
-Syntax Types provide two Static types for inferring TypeScript syntax from strings.
+Syntax Types provide two Static types for inferring TypeScript types and TypeBox schematics from strings.
 
 ```typescript
 import { StaticParseAsSchema, StaticParseAsType } from '@sinclair/typebox/syntax' 
@@ -1190,7 +1198,7 @@ const B = Parse(`{
 }`)
 ```
 
-In cases where Syntax Types busts through TypeScript instantiation limits, TypeBox offers a fallback ParseOnly function which will Parse the types at runtime, but not infer the type. This function can also be used for parsing non-constant strings.
+In cases where Syntax Types exceed TypeScript's instantiation limits, TypeBox offers a fallback ParseOnly function, which will only parse but not infer. This function can also be used to parse types where the syntax is statically unknown to TypeScript (for example, when loading types from disk).
 
 ```typescript
 import { ParseOnly } from '@sinclair/typebox/syntax'