@sinclair/typebox 0.34.0 → 0.34.2

package/build/cjs/value/check/check.js

@@ -17,9 +17,9 @@ const index_9 = require("../../type/never/index");
 // ------------------------------------------------------------------
 const index_10 = require("../guard/index");
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-const type_1 = require("../../type/guard/type");
+const kind_1 = require("../../type/guard/kind");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -174,7 +174,7 @@ function FromIntersect(schema, references, value) {
         const check2 = Object.getOwnPropertyNames(value).every((key) => keyPattern.test(key));
         return check1 && check2;
     }
-    else if ((0, type_1.IsSchema)(schema.unevaluatedProperties)) {
+    else if ((0, kind_1.IsSchema)(schema.unevaluatedProperties)) {
         const keyCheck = new RegExp((0, index_5.KeyOfPattern)(schema));
         const check2 = Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit(schema.unevaluatedProperties, references, value[key]));
         return check1 && check2;

package/build/cjs/value/transform/decode.js

@@ -14,9 +14,9 @@ const index_5 = require("../check/index");
 // ------------------------------------------------------------------
 const index_6 = require("../guard/index");
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-const type_1 = require("../../type/guard/type");
+const kind_1 = require("../../type/guard/kind");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -48,7 +48,7 @@ exports.TransformDecodeError = TransformDecodeError;
 // prettier-ignore
 function Default(schema, path, value) {
     try {
-        return (0, type_1.IsTransform)(schema) ? schema[index_1.TransformKind].Decode(value) : value;
+        return (0, kind_1.IsTransform)(schema) ? schema[index_1.TransformKind].Decode(value) : value;
     }
     catch (error) {
         throw new TransformDecodeError(schema, path, value, error);
@@ -71,7 +71,7 @@ function FromIntersect(schema, references, path, value) {
         if (knownKey in knownProperties) {
             knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
         }
-    if (!(0, type_1.IsTransform)(schema.unevaluatedProperties)) {
+    if (!(0, kind_1.IsTransform)(schema.unevaluatedProperties)) {
         return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -107,13 +107,13 @@ function FromObject(schema, references, path, value) {
         // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
         // property policy, then we need to continue. This is a special case for optional property handling 
         // where a transforms wrapped in a optional modifiers should not run.
-        if ((0, index_6.IsUndefined)(knownProperties[key]) && (!(0, type_1.IsUndefined)(schema.properties[key]) ||
+        if ((0, index_6.IsUndefined)(knownProperties[key]) && (!(0, kind_1.IsUndefined)(schema.properties[key]) ||
             policy_1.TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
             continue;
         // decode property
         knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
     }
-    if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
+    if (!(0, kind_1.IsSchema)(schema.additionalProperties)) {
         return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -136,7 +136,7 @@ function FromRecord(schema, references, path, value) {
         if (knownKeys.test(key)) {
             knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
         }
-    if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
+    if (!(0, kind_1.IsSchema)(schema.additionalProperties)) {
         return Default(schema, path, knownProperties);
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);

package/build/cjs/value/transform/encode.js

@@ -14,9 +14,9 @@ const index_5 = require("../check/index");
 // ------------------------------------------------------------------
 const index_6 = require("../guard/index");
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-const type_1 = require("../../type/guard/type");
+const kind_1 = require("../../type/guard/kind");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
@@ -47,7 +47,7 @@ exports.TransformEncodeError = TransformEncodeError;
 // prettier-ignore
 function Default(schema, path, value) {
     try {
-        return (0, type_1.IsTransform)(schema) ? schema[index_1.TransformKind].Encode(value) : value;
+        return (0, kind_1.IsTransform)(schema) ? schema[index_1.TransformKind].Encode(value) : value;
     }
     catch (error) {
         throw new TransformEncodeError(schema, path, value, error);
@@ -81,7 +81,7 @@ function FromIntersect(schema, references, path, value) {
         if (knownKey in knownProperties) {
             knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
         }
-    if (!(0, type_1.IsTransform)(schema.unevaluatedProperties)) {
+    if (!(0, kind_1.IsTransform)(schema.unevaluatedProperties)) {
         return knownProperties;
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -110,13 +110,13 @@ function FromObject(schema, references, path, value) {
         // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
         // property policy, then we need to continue. This is a special case for optional property handling 
         // where a transforms wrapped in a optional modifiers should not run.
-        if ((0, index_6.IsUndefined)(knownProperties[key]) && (!(0, type_1.IsUndefined)(schema.properties[key]) ||
+        if ((0, index_6.IsUndefined)(knownProperties[key]) && (!(0, kind_1.IsUndefined)(schema.properties[key]) ||
             policy_1.TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
             continue;
         // encode property
         knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
     }
-    if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
+    if (!(0, kind_1.IsSchema)(schema.additionalProperties)) {
         return knownProperties;
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -140,7 +140,7 @@ function FromRecord(schema, references, path, value) {
         if (knownKeys.test(key)) {
             knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
         }
-    if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
+    if (!(0, kind_1.IsSchema)(schema.additionalProperties)) {
         return knownProperties;
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);

package/build/cjs/value/transform/has.js

@@ -5,76 +5,76 @@ exports.HasTransform = HasTransform;
 const index_1 = require("../deref/index");
 const index_2 = require("../../type/symbols/index");
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-const type_1 = require("../../type/guard/type");
+const kind_1 = require("../../type/guard/kind");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
 const index_3 = require("../guard/index");
 // prettier-ignore
 function FromArray(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.items, references);
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.items, references);
 }
 // prettier-ignore
 function FromAsyncIterator(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.items, references);
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.items, references);
 }
 // prettier-ignore
 function FromConstructor(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
 function FromFunction(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
 function FromIntersect(schema, references) {
-    return (0, type_1.IsTransform)(schema) || (0, type_1.IsTransform)(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
+    return (0, kind_1.IsTransform)(schema) || (0, kind_1.IsTransform)(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
 function FromIterator(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.items, references);
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.items, references);
 }
 // prettier-ignore
 function FromNot(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.not, references);
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.not, references);
 }
 // prettier-ignore
 function FromObject(schema, references) {
-    return ((0, type_1.IsTransform)(schema) ||
+    return ((0, kind_1.IsTransform)(schema) ||
         Object.values(schema.properties).some((schema) => Visit(schema, references)) ||
-        ((0, type_1.IsSchema)(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
+        ((0, kind_1.IsSchema)(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
 }
 // prettier-ignore
 function FromPromise(schema, references) {
-    return (0, type_1.IsTransform)(schema) || Visit(schema.item, references);
+    return (0, kind_1.IsTransform)(schema) || Visit(schema.item, references);
 }
 // prettier-ignore
 function FromRecord(schema, references) {
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const property = schema.patternProperties[pattern];
-    return (0, type_1.IsTransform)(schema) || Visit(property, references) || ((0, type_1.IsSchema)(schema.additionalProperties) && (0, type_1.IsTransform)(schema.additionalProperties));
+    return (0, kind_1.IsTransform)(schema) || Visit(property, references) || ((0, kind_1.IsSchema)(schema.additionalProperties) && (0, kind_1.IsTransform)(schema.additionalProperties));
 }
 // prettier-ignore
 function FromRef(schema, references) {
-    if ((0, type_1.IsTransform)(schema))
+    if ((0, kind_1.IsTransform)(schema))
         return true;
     return Visit((0, index_1.Deref)(schema, references), references);
 }
 // prettier-ignore
 function FromThis(schema, references) {
-    if ((0, type_1.IsTransform)(schema))
+    if ((0, kind_1.IsTransform)(schema))
         return true;
     return Visit((0, index_1.Deref)(schema, references), references);
 }
 // prettier-ignore
 function FromTuple(schema, references) {
-    return (0, type_1.IsTransform)(schema) || (!(0, index_3.IsUndefined)(schema.items) && schema.items.some((schema) => Visit(schema, references)));
+    return (0, kind_1.IsTransform)(schema) || (!(0, index_3.IsUndefined)(schema.items) && schema.items.some((schema) => Visit(schema, references)));
 }
 // prettier-ignore
 function FromUnion(schema, references) {
-    return (0, type_1.IsTransform)(schema) || schema.anyOf.some((schema) => Visit(schema, references));
+    return (0, kind_1.IsTransform)(schema) || schema.anyOf.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
 function Visit(schema, references) {
@@ -114,7 +114,7 @@ function Visit(schema, references) {
         case 'Union':
             return FromUnion(schema_, references_);
         default:
-            return (0, type_1.IsTransform)(schema);
+            return (0, kind_1.IsTransform)(schema);
     }
 }
 const visited = new Set();

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

@@ -12,7 +12,10 @@ export declare const Module: Runtime.Module<{
     }>;
     ModuleType: Runtime.IUnion<unknown>;
     ModuleProperties: Runtime.IUnion<Types.TProperties>;
-    ModuleDeclaration: Runtime.ITuple<Types.TModule<Types.TProperties>>;
+    ModuleDeclaration: Runtime.ITuple<Types.TModule<Types.TProperties, {
+        [x: string]: Types.TSchema;
+        [x: number]: Types.TSchema;
+    }>>;
     Literal: Runtime.IUnion<Types.TLiteral<string> | Types.TLiteral<number> | Types.TLiteral<boolean>>;
     Keyword: Runtime.IUnion<Types.TAny | Types.TNever | Types.TString | Types.TBoolean | Types.TNumber | Types.TInteger | Types.TBigInt | Types.TNull | Types.TSymbol | Types.TUndefined | Types.TUnknown | Types.TVoid>;
     KeyOf: Runtime.IUnion<boolean>;

package/build/esm/syntax/runtime.mjs

@@ -279,7 +279,9 @@ const FactorExtends = (Type, Extends) => {
 // prettier-ignore
 const FactorIndexArray = (Type, IndexArray) => {
     const [Left, Right] = DestructureRight(IndexArray);
-    return (!Types.ValueGuard.IsUndefined(Right) ? (Right.length === 1 ? Types.Index(FactorIndexArray(Type, Left), Right[0]) :
+    return (!Types.ValueGuard.IsUndefined(Right) ? (
+    // note: Indexed types require reimplementation to replace `[number]` indexers
+    Right.length === 1 ? Types.Index(FactorIndexArray(Type, Left), Right[0]) :
         Right.length === 0 ? Types.Array(FactorIndexArray(Type, Left)) :
             Types.Never()) : Type);
 };

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

@@ -456,7 +456,7 @@ type Partial = Static.Tuple<[
     Static.Const<RAngle>
 ], PartialMapping>;
 interface RequiredMapping extends Static.IMapping {
-    output: this['input'] extends ['Required', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TPartial<Type> : never;
+    output: this['input'] extends ['Required', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TRequired<Type> : never;
 }
 type Required = Static.Tuple<[
     Static.Const<'Required'>,
@@ -465,7 +465,7 @@ type Required = Static.Tuple<[
     Static.Const<RAngle>
 ], RequiredMapping>;
 interface PickMapping extends Static.IMapping {
-    output: this['input'] extends ['Pick', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle] ? Types.TPick<Type, Types.TIndexPropertyKeys<PropertyKey>> : never;
+    output: this['input'] extends ['Pick', LAngle, infer Type extends Types.TSchema, Comma, infer Key extends Types.TSchema, RAngle] ? Types.TPick<Type, Key> : never;
 }
 type Pick = Static.Tuple<[
     Static.Const<'Pick'>,
@@ -476,7 +476,7 @@ type Pick = Static.Tuple<[
     Static.Const<RAngle>
 ], PickMapping>;
 interface OmitMapping extends Static.IMapping {
-    output: this['input'] extends ['Omit', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle] ? Types.TOmit<Type, Types.TIndexPropertyKeys<PropertyKey>> : never;
+    output: this['input'] extends ['Omit', LAngle, infer Type extends Types.TSchema, Comma, infer Key extends Types.TSchema, RAngle] ? Types.TOmit<Type, Key> : never;
 }
 type Omit = Static.Tuple<[
     Static.Const<'Omit'>,

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

@@ -24,5 +24,5 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
     items: T;
 }
 /** `[Json]` Creates an Array type */
-export declare function Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
+export declare function Array<Type extends TSchema>(items: Type, options?: ArrayOptions): TArray<Type>;
 export {};

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

@@ -1,9 +1,14 @@
+import { Ensure } from '../helpers/index.mjs';
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TComputed } from '../computed/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TPromise } from '../promise/index.mjs';
-type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TAwaited<L>]> : Acc;
-export type TAwaited<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TPromise<infer S> ? TAwaited<S> : T;
+import { type TRef } from '../ref/index.mjs';
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<(TComputed<'Awaited', [TComputed<Target, Parameters>]>)>;
+type TFromRef<Ref extends string> = Ensure<TComputed<'Awaited', [TRef<Ref>]>>;
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<Right, [...Result, TAwaited<Left>]> : Result);
+export type TAwaited<Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> : Type extends TPromise<infer Type extends TSchema> ? TAwaited<Type> : Type);
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-export declare function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): TAwaited<T>;
+export declare function Awaited<T extends TSchema>(type: T, options?: SchemaOptions): TAwaited<T>;
 export {};

package/build/esm/type/awaited/awaited.mjs

@@ -1,37 +1,37 @@
+import { CreateType } from '../create/type.mjs';
+import { Computed } from '../computed/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
-import { CreateType } from '../create/type.mjs';
+import { Ref } from '../ref/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsIntersect, IsUnion, IsPromise } from '../guard/kind.mjs';
+import { IsIntersect, IsUnion, IsPromise, IsRef, IsComputed } from '../guard/kind.mjs';
+// prettier-ignore
+function FromComputed(target, parameters) {
+    return Computed('Awaited', [Computed(target, parameters)]);
+}
 // prettier-ignore
-function FromRest(T) {
-    return T.map(L => AwaitedResolve(L));
+function FromRef($ref) {
+    return Computed('Awaited', [Ref($ref)]);
 }
 // prettier-ignore
-function FromIntersect(T) {
-    return Intersect(FromRest(T));
+function FromIntersect(types) {
+    return Intersect(FromRest(types));
 }
 // prettier-ignore
-function FromUnion(T) {
-    return Union(FromRest(T));
+function FromUnion(types) {
+    return Union(FromRest(types));
 }
 // prettier-ignore
-function FromPromise(T) {
-    return AwaitedResolve(T);
+function FromPromise(type) {
+    return Awaited(type);
 }
-// ----------------------------------------------------------------
-// AwaitedResolve
-// ----------------------------------------------------------------
 // prettier-ignore
-function AwaitedResolve(T) {
-    return (IsIntersect(T) ? FromIntersect(T.allOf) :
-        IsUnion(T) ? FromUnion(T.anyOf) :
-            IsPromise(T) ? FromPromise(T.item) :
-                T);
+function FromRest(types) {
+    return types.map(type => Awaited(type));
 }
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-export function Awaited(T, options) {
-    return CreateType(AwaitedResolve(T), options);
+export function Awaited(type, options) {
+    return CreateType(IsComputed(type) ? FromComputed(type.target, type.parameters) : IsIntersect(type) ? FromIntersect(type.allOf) : IsUnion(type) ? FromUnion(type.anyOf) : IsPromise(type) ? FromPromise(type.item) : IsRef(type) ? FromRef(type.$ref) : type, options);
 }

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

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/symbols.mjs';
+export interface TComputed<Target extends string = string, Parameters extends TSchema[] = []> extends TSchema {
+    [Kind]: 'Computed';
+    target: Target;
+    parameters: Parameters;
+}
+/** `[Internal]` Creates a deferred computed type. This type is used exclusively in modules to defer resolution of computable types that contain interior references  */
+export declare function Computed<Target extends string, Parameters extends TSchema[]>(target: Target, parameters: [...Parameters], options?: SchemaOptions): TComputed<Target, Parameters>;

package/build/esm/type/computed/computed.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/index.mjs';
+import { Kind } from '../symbols/symbols.mjs';
+/** `[Internal]` Creates a deferred computed type. This type is used exclusively in modules to defer resolution of computable types that contain interior references  */
+export function Computed(target, parameters, options) {
+    return CreateType({ [Kind]: 'Computed', target, parameters }, options);
+}

package/build/esm/type/computed/index.d.mts

@@ -0,0 +1 @@
+export * from './computed.mjs';

package/build/esm/type/computed/index.mjs

@@ -0,0 +1 @@
+export * from './computed.mjs';

package/build/esm/type/guard/kind.d.mts

@@ -1,8 +1,9 @@
 import { Kind, Hint, TransformKind } from '../symbols/index.mjs';
 import { TransformOptions } from '../transform/index.mjs';
-import { TTemplateLiteral } from '../template-literal/index.mjs';
-import { TArray } from '../array/index.mjs';
-import { TBoolean } from '../boolean/index.mjs';
+import type { TTemplateLiteral } from '../template-literal/index.mjs';
+import type { TArray } from '../array/index.mjs';
+import type { TBoolean } from '../boolean/index.mjs';
+import type { TComputed } from '../computed/index.mjs';
 import type { TRecord } from '../record/index.mjs';
 import type { TString } from '../string/index.mjs';
 import type { TUnion } from '../union/index.mjs';
@@ -15,7 +16,7 @@ import type { TImport } from '../module/index.mjs';
 import type { TInteger } from '../integer/index.mjs';
 import type { TIntersect } from '../intersect/index.mjs';
 import type { TIterator } from '../iterator/index.mjs';
-import type { TLiteral } from '../literal/index.mjs';
+import type { TLiteral, TLiteralValue } from '../literal/index.mjs';
 import type { TMappedKey, TMappedResult } from '../mapped/index.mjs';
 import type { TNever } from '../never/index.mjs';
 import type { TNot } from '../not/index.mjs';
@@ -51,6 +52,8 @@ export declare function IsAsyncIterator(value: unknown): value is TAsyncIterator
 export declare function IsBigInt(value: unknown): value is TBigInt;
 /** `[Kind-Only]` Returns true if the given value is TBoolean */
 export declare function IsBoolean(value: unknown): value is TBoolean;
+/** `[Kind-Only]` Returns true if the given value is TComputed */
+export declare function IsComputed(value: unknown): value is TComputed;
 /** `[Kind-Only]` Returns true if the given value is TConstructor */
 export declare function IsConstructor(value: unknown): value is TConstructor;
 /** `[Kind-Only]` Returns true if the given value is TDate */
@@ -77,6 +80,8 @@ export declare function IsLiteralString(value: unknown): value is TLiteral<strin
 export declare function IsLiteralNumber(value: unknown): value is TLiteral<number>;
 /** `[Kind-Only]` Returns true if the given value is TLiteral<boolean> */
 export declare function IsLiteralBoolean(value: unknown): value is TLiteral<boolean>;
+/** `[Kind-Only]` Returns true if the given value is TLiteralValue */
+export declare function IsLiteralValue(value: unknown): value is TLiteralValue;
 /** `[Kind-Only]` Returns true if the given value is TLiteral */
 export declare function IsLiteral(value: unknown): value is TLiteral;
 /** `[Kind-Only]` Returns true if the given value is a TMappedKey */

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

@@ -28,6 +28,10 @@ export function IsBigInt(value) {
 export function IsBoolean(value) {
     return IsKindOf(value, 'Boolean');
 }
+/** `[Kind-Only]` Returns true if the given value is TComputed */
+export function IsComputed(value) {
+    return IsKindOf(value, 'Computed');
+}
 /** `[Kind-Only]` Returns true if the given value is TConstructor */
 export function IsConstructor(value) {
     return IsKindOf(value, 'Constructor');
@@ -76,6 +80,10 @@ export function IsLiteralNumber(value) {
 export function IsLiteralBoolean(value) {
     return IsLiteral(value) && ValueGuard.IsBoolean(value.const);
 }
+/** `[Kind-Only]` Returns true if the given value is TLiteralValue */
+export function IsLiteralValue(value) {
+    return ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value) || ValueGuard.IsString(value);
+}
 /** `[Kind-Only]` Returns true if the given value is TLiteral */
 export function IsLiteral(value) {
     return IsKindOf(value, 'Literal');

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

@@ -1,9 +1,10 @@
 import { Kind, Hint, TransformKind } from '../symbols/index.mjs';
 import { TypeBoxError } from '../error/index.mjs';
 import { TransformOptions } from '../transform/index.mjs';
-import { TTemplateLiteral } from '../template-literal/index.mjs';
-import { TArray } from '../array/index.mjs';
-import { TBoolean } from '../boolean/index.mjs';
+import type { TTemplateLiteral } from '../template-literal/index.mjs';
+import type { TArray } from '../array/index.mjs';
+import type { TBoolean } from '../boolean/index.mjs';
+import type { TComputed } from '../computed/index.mjs';
 import type { TRecord } from '../record/index.mjs';
 import type { TString } from '../string/index.mjs';
 import type { TUnion } from '../union/index.mjs';
@@ -54,6 +55,8 @@ export declare function IsAsyncIterator(value: unknown): value is TAsyncIterator
 export declare function IsBigInt(value: unknown): value is TBigInt;
 /** Returns true if the given value is TBoolean */
 export declare function IsBoolean(value: unknown): value is TBoolean;
+/** Returns true if the given value is TComputed */
+export declare function IsComputed(value: unknown): value is TComputed;
 /** Returns true if the given value is TConstructor */
 export declare function IsConstructor(value: unknown): value is TConstructor;
 /** Returns true if the given value is TDate */

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

@@ -9,6 +9,7 @@ const KnownTypes = [
     'AsyncIterator',
     'BigInt',
     'Boolean',
+    'Computed',
     'Constructor',
     'Date',
     'Enum',
@@ -142,6 +143,10 @@ export function IsBoolean(value) {
         value.type === 'boolean' &&
         IsOptionalString(value.$id));
 }
+/** 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));
+}
 /** Returns true if the given value is TConstructor */
 export function IsConstructor(value) {
     // prettier-ignore

package/build/esm/type/indexed/indexed-from-mapped-key.d.mts

@@ -3,11 +3,11 @@ import type { Ensure, Evaluate } from '../helpers/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TIndex } from './indexed.mjs';
 import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
-type TMappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
-    [_ in K]: TIndex<T, [K]>;
+type TMappedIndexPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+    [_ in Key]: TIndex<Type, [Key]>;
 };
-type TMappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedIndexPropertyKeys<T, R, Acc & TMappedIndexPropertyKey<T, L>> : Acc);
-type TMappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<TMappedIndexPropertyKeys<T, K['keys']>>;
-export type TIndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>> = (Ensure<TMappedResult<P>>);
-export declare function IndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>>(T: T, K: K, options?: SchemaOptions): TMappedResult<P>;
+type TMappedIndexPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (PropertyKeys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? TMappedIndexPropertyKeys<Type, Right, Result & TMappedIndexPropertyKey<Type, Left>> : Result);
+type TMappedIndexProperties<Type extends TSchema, MappedKey extends TMappedKey> = Evaluate<TMappedIndexPropertyKeys<Type, MappedKey['keys']>>;
+export type TIndexFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TMappedIndexProperties<Type, MappedKey>> = (Ensure<TMappedResult<Properties>>);
+export declare function IndexFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TMappedIndexProperties<Type, MappedKey>>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedResult<Properties>;
 export {};

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

@@ -2,21 +2,21 @@ import { Index } from './indexed.mjs';
 import { MappedResult } from '../mapped/index.mjs';
 import { Clone } from '../clone/value.mjs';
 // prettier-ignore
-function MappedIndexPropertyKey(T, K, options) {
-    return { [K]: Index(T, [K], Clone(options)) };
+function MappedIndexPropertyKey(type, key, options) {
+    return { [key]: Index(type, [key], Clone(options)) };
 }
 // prettier-ignore
-function MappedIndexPropertyKeys(T, K, options) {
-    return K.reduce((Acc, L) => {
-        return { ...Acc, ...MappedIndexPropertyKey(T, L, options) };
+function MappedIndexPropertyKeys(type, propertyKeys, options) {
+    return propertyKeys.reduce((result, left) => {
+        return { ...result, ...MappedIndexPropertyKey(type, left, options) };
     }, {});
 }
 // prettier-ignore
-function MappedIndexProperties(T, K, options) {
-    return MappedIndexPropertyKeys(T, K.keys, options);
+function MappedIndexProperties(type, mappedKey, options) {
+    return MappedIndexPropertyKeys(type, mappedKey.keys, options);
 }
 // prettier-ignore
-export function IndexFromMappedKey(T, K, options) {
-    const P = MappedIndexProperties(T, K, options);
-    return MappedResult(P);
+export function IndexFromMappedKey(type, mappedKey, options) {
+    const properties = MappedIndexProperties(type, mappedKey, options);
+    return MappedResult(properties);
 }

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

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

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

@@ -2,19 +2,20 @@ import { MappedResult } from '../mapped/index.mjs';
 import { IndexPropertyKeys } from './indexed-property-keys.mjs';
 import { Index } from './index.mjs';
 // prettier-ignore
-function FromProperties(T, P, options) {
-    const Acc = {};
-    for (const K2 of Object.getOwnPropertyNames(P)) {
-        Acc[K2] = Index(T, IndexPropertyKeys(P[K2]), options);
+function FromProperties(type, properties, options) {
+    const result = {};
+    for (const K2 of Object.getOwnPropertyNames(properties)) {
+        const keys = IndexPropertyKeys(properties[K2]);
+        result[K2] = Index(type, keys, options);
     }
-    return Acc;
+    return result;
 }
 // prettier-ignore
-function FromMappedResult(T, R, options) {
-    return FromProperties(T, R.properties, options);
+function FromMappedResult(type, mappedResult, options) {
+    return FromProperties(type, mappedResult.properties, options);
 }
 // prettier-ignore
-export function IndexFromMappedResult(T, R, options) {
-    const P = FromMappedResult(T, R, options);
-    return MappedResult(P);
+export function IndexFromMappedResult(type, mappedResult, options) {
+    const properties = FromMappedResult(type, mappedResult, options);
+    return MappedResult(properties);
 }