@sinclair/typebox 0.34.4 → 0.34.6

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/guard/kind.js

@@ -247,6 +247,7 @@ function IsSchema(value) {
         IsBoolean(value) ||
         IsBigInt(value) ||
         IsAsyncIterator(value) ||
+        IsComputed(value) ||
         IsConstructor(value) ||
         IsDate(value) ||
         IsFunction(value) ||

package/build/cjs/type/guard/type.js

@@ -199,7 +199,11 @@ function IsBoolean(value) {
 }
 /** Returns true if the given value is TComputed */
 function IsComputed(value) {
-    return IsKindOf(value, 'Computed') && IsString(value.target) && ValueGuard.IsArray(value.parameters) && value.parameters.every((schema) => IsSchema(schema));
+    // prettier-ignore
+    return (IsKindOf(value, 'Computed') &&
+        ValueGuard.IsString(value.target) &&
+        ValueGuard.IsArray(value.parameters) &&
+        value.parameters.every((schema) => IsSchema(schema)));
 }
 /** Returns true if the given value is TConstructor */
 function IsConstructor(value) {
@@ -517,6 +521,7 @@ function IsSchema(value) {
         IsBoolean(value) ||
         IsBigInt(value) ||
         IsAsyncIterator(value) ||
+        IsComputed(value) ||
         IsConstructor(value) ||
         IsDate(value) ||
         IsFunction(value) ||

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

@@ -9,6 +9,7 @@ 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';
@@ -19,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>>>)>;
@@ -36,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 TEnum<infer _ extends TEnumRecord> ? Static<Type> : 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/guard/kind.mjs

@@ -196,6 +196,7 @@ export function IsSchema(value) {
         IsBoolean(value) ||
         IsBigInt(value) ||
         IsAsyncIterator(value) ||
+        IsComputed(value) ||
         IsConstructor(value) ||
         IsDate(value) ||
         IsFunction(value) ||

package/build/esm/type/guard/type.mjs

@@ -145,7 +145,11 @@ export function IsBoolean(value) {
 }
 /** Returns true if the given value is TComputed */
 export function IsComputed(value) {
-    return IsKindOf(value, 'Computed') && IsString(value.target) && ValueGuard.IsArray(value.parameters) && value.parameters.every((schema) => IsSchema(schema));
+    // prettier-ignore
+    return (IsKindOf(value, 'Computed') &&
+        ValueGuard.IsString(value.target) &&
+        ValueGuard.IsArray(value.parameters) &&
+        value.parameters.every((schema) => IsSchema(schema)));
 }
 /** Returns true if the given value is TConstructor */
 export function IsConstructor(value) {
@@ -463,6 +467,7 @@ export function IsSchema(value) {
         IsBoolean(value) ||
         IsBigInt(value) ||
         IsAsyncIterator(value) ||
+        IsComputed(value) ||
         IsConstructor(value) ||
         IsDate(value) ||
         IsFunction(value) ||

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

@@ -4,7 +4,7 @@ import { Awaited } from '../awaited/index.mjs';
 import { AsyncIterator } from '../async-iterator/index.mjs';
 import { Constructor } from '../constructor/index.mjs';
 import { Index } from '../indexed/index.mjs';
-import { Function } from '../function/index.mjs';
+import { Function as FunctionType } from '../function/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Iterator } from '../iterator/index.mjs';
 import { KeyOf } from '../keyof/index.mjs';
@@ -93,7 +93,7 @@ function FromConstructor(moduleProperties, parameters, instanceType) {
 }
 // prettier-ignore
 function FromFunction(moduleProperties, parameters, returnType) {
-    return Function(FromRest(moduleProperties, parameters), FromType(moduleProperties, returnType));
+    return FunctionType(FromRest(moduleProperties, parameters), FromType(moduleProperties, returnType));
 }
 function FromTuple(moduleProperties, types) {
     return Tuple(FromRest(moduleProperties, types));

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

@@ -9,6 +9,7 @@ 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';
@@ -19,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>>>)>;
@@ -36,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 TEnum<infer _ extends TEnumRecord> ? Static<Type> : 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.4",
+  "version": "0.34.6",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",