@sinclair/typebox 0.34.0 → 0.34.2

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

@@ -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/cjs/syntax/runtime.js

@@ -283,7 +283,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/cjs/syntax/static.d.ts

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

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

@@ -1,9 +1,14 @@
+import { Ensure } from '../helpers/index';
 import type { TSchema, SchemaOptions } from '../schema/index';
+import { type TComputed } from '../computed/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TPromise } from '../promise/index';
-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';
+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/cjs/type/awaited/awaited.js

@@ -2,40 +2,40 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Awaited = Awaited;
-const index_1 = require("../intersect/index");
-const index_2 = require("../union/index");
 const type_1 = require("../create/type");
+const index_1 = require("../computed/index");
+const index_2 = require("../intersect/index");
+const index_3 = require("../union/index");
+const index_4 = require("../ref/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
-function FromRest(T) {
-    return T.map(L => AwaitedResolve(L));
+function FromComputed(target, parameters) {
+    return (0, index_1.Computed)('Awaited', [(0, index_1.Computed)(target, parameters)]);
 }
 // prettier-ignore
-function FromIntersect(T) {
-    return (0, index_1.Intersect)(FromRest(T));
+function FromRef($ref) {
+    return (0, index_1.Computed)('Awaited', [(0, index_4.Ref)($ref)]);
 }
 // prettier-ignore
-function FromUnion(T) {
-    return (0, index_2.Union)(FromRest(T));
+function FromIntersect(types) {
+    return (0, index_2.Intersect)(FromRest(types));
 }
 // prettier-ignore
-function FromPromise(T) {
-    return AwaitedResolve(T);
+function FromUnion(types) {
+    return (0, index_3.Union)(FromRest(types));
 }
-// ----------------------------------------------------------------
-// AwaitedResolve
-// ----------------------------------------------------------------
 // prettier-ignore
-function AwaitedResolve(T) {
-    return ((0, kind_1.IsIntersect)(T) ? FromIntersect(T.allOf) :
-        (0, kind_1.IsUnion)(T) ? FromUnion(T.anyOf) :
-            (0, kind_1.IsPromise)(T) ? FromPromise(T.item) :
-                T);
+function FromPromise(type) {
+    return Awaited(type);
+}
+// prettier-ignore
+function FromRest(types) {
+    return types.map(type => Awaited(type));
 }
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-function Awaited(T, options) {
-    return (0, type_1.CreateType)(AwaitedResolve(T), options);
+function Awaited(type, options) {
+    return (0, type_1.CreateType)((0, kind_1.IsComputed)(type) ? FromComputed(type.target, type.parameters) : (0, kind_1.IsIntersect)(type) ? FromIntersect(type.allOf) : (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf) : (0, kind_1.IsPromise)(type) ? FromPromise(type.item) : (0, kind_1.IsRef)(type) ? FromRef(type.$ref) : type, options);
 }

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

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/symbols';
+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/cjs/type/computed/computed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Computed = Computed;
+const index_1 = require("../create/index");
+const symbols_1 = require("../symbols/symbols");
+/** `[Internal]` Creates a deferred computed type. This type is used exclusively in modules to defer resolution of computable types that contain interior references  */
+function Computed(target, parameters, options) {
+    return (0, index_1.CreateType)({ [symbols_1.Kind]: 'Computed', target, parameters }, options);
+}

package/build/cjs/type/computed/index.d.ts

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

package/build/cjs/type/computed/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./computed"), exports);

package/build/cjs/type/guard/kind.d.ts

@@ -1,8 +1,9 @@
 import { Kind, Hint, TransformKind } from '../symbols/index';
 import { TransformOptions } from '../transform/index';
-import { TTemplateLiteral } from '../template-literal/index';
-import { TArray } from '../array/index';
-import { TBoolean } from '../boolean/index';
+import type { TTemplateLiteral } from '../template-literal/index';
+import type { TArray } from '../array/index';
+import type { TBoolean } from '../boolean/index';
+import type { TComputed } from '../computed/index';
 import type { TRecord } from '../record/index';
 import type { TString } from '../string/index';
 import type { TUnion } from '../union/index';
@@ -15,7 +16,7 @@ import type { TImport } from '../module/index';
 import type { TInteger } from '../integer/index';
 import type { TIntersect } from '../intersect/index';
 import type { TIterator } from '../iterator/index';
-import type { TLiteral } from '../literal/index';
+import type { TLiteral, TLiteralValue } from '../literal/index';
 import type { TMappedKey, TMappedResult } from '../mapped/index';
 import type { TNever } from '../never/index';
 import type { TNot } from '../not/index';
@@ -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/cjs/type/guard/kind.js

@@ -8,6 +8,7 @@ exports.IsArray = IsArray;
 exports.IsAsyncIterator = IsAsyncIterator;
 exports.IsBigInt = IsBigInt;
 exports.IsBoolean = IsBoolean;
+exports.IsComputed = IsComputed;
 exports.IsConstructor = IsConstructor;
 exports.IsDate = IsDate;
 exports.IsFunction = IsFunction;
@@ -20,6 +21,7 @@ exports.IsKindOf = IsKindOf;
 exports.IsLiteralString = IsLiteralString;
 exports.IsLiteralNumber = IsLiteralNumber;
 exports.IsLiteralBoolean = IsLiteralBoolean;
+exports.IsLiteralValue = IsLiteralValue;
 exports.IsLiteral = IsLiteral;
 exports.IsMappedKey = IsMappedKey;
 exports.IsMappedResult = IsMappedResult;
@@ -77,6 +79,10 @@ function IsBigInt(value) {
 function IsBoolean(value) {
     return IsKindOf(value, 'Boolean');
 }
+/** `[Kind-Only]` Returns true if the given value is TComputed */
+function IsComputed(value) {
+    return IsKindOf(value, 'Computed');
+}
 /** `[Kind-Only]` Returns true if the given value is TConstructor */
 function IsConstructor(value) {
     return IsKindOf(value, 'Constructor');
@@ -125,6 +131,10 @@ function IsLiteralNumber(value) {
 function IsLiteralBoolean(value) {
     return IsLiteral(value) && ValueGuard.IsBoolean(value.const);
 }
+/** `[Kind-Only]` Returns true if the given value is TLiteralValue */
+function IsLiteralValue(value) {
+    return ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value) || ValueGuard.IsString(value);
+}
 /** `[Kind-Only]` Returns true if the given value is TLiteral */
 function IsLiteral(value) {
     return IsKindOf(value, 'Literal');

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

@@ -1,9 +1,10 @@
 import { Kind, Hint, TransformKind } from '../symbols/index';
 import { TypeBoxError } from '../error/index';
 import { TransformOptions } from '../transform/index';
-import { TTemplateLiteral } from '../template-literal/index';
-import { TArray } from '../array/index';
-import { TBoolean } from '../boolean/index';
+import type { TTemplateLiteral } from '../template-literal/index';
+import type { TArray } from '../array/index';
+import type { TBoolean } from '../boolean/index';
+import type { TComputed } from '../computed/index';
 import type { TRecord } from '../record/index';
 import type { TString } from '../string/index';
 import type { TUnion } from '../union/index';
@@ -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/cjs/type/guard/type.js

@@ -9,6 +9,7 @@ exports.IsArray = IsArray;
 exports.IsAsyncIterator = IsAsyncIterator;
 exports.IsBigInt = IsBigInt;
 exports.IsBoolean = IsBoolean;
+exports.IsComputed = IsComputed;
 exports.IsConstructor = IsConstructor;
 exports.IsDate = IsDate;
 exports.IsFunction = IsFunction;
@@ -62,6 +63,7 @@ const KnownTypes = [
     'AsyncIterator',
     'BigInt',
     'Boolean',
+    'Computed',
     'Constructor',
     'Date',
     'Enum',
@@ -195,6 +197,10 @@ function IsBoolean(value) {
         value.type === 'boolean' &&
         IsOptionalString(value.$id));
 }
+/** 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));
+}
 /** Returns true if the given value is TConstructor */
 function IsConstructor(value) {
     // prettier-ignore

package/build/cjs/type/indexed/indexed-from-mapped-key.d.ts

@@ -3,11 +3,11 @@ import type { Ensure, Evaluate } from '../helpers/index';
 import type { TProperties } from '../object/index';
 import { type TIndex } from './indexed';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
-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/cjs/type/indexed/indexed-from-mapped-key.js

@@ -6,21 +6,21 @@ const indexed_1 = require("./indexed");
 const index_1 = require("../mapped/index");
 const value_1 = require("../clone/value");
 // prettier-ignore
-function MappedIndexPropertyKey(T, K, options) {
-    return { [K]: (0, indexed_1.Index)(T, [K], (0, value_1.Clone)(options)) };
+function MappedIndexPropertyKey(type, key, options) {
+    return { [key]: (0, indexed_1.Index)(type, [key], (0, value_1.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
-function IndexFromMappedKey(T, K, options) {
-    const P = MappedIndexProperties(T, K, options);
-    return (0, index_1.MappedResult)(P);
+function IndexFromMappedKey(type, mappedKey, options) {
+    const properties = MappedIndexProperties(type, mappedKey, options);
+    return (0, index_1.MappedResult)(properties);
 }

package/build/cjs/type/indexed/indexed-from-mapped-result.d.ts

@@ -3,10 +3,10 @@ import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TIndexPropertyKeys } from './indexed-property-keys';
 import { type TIndex } from './index';
-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/cjs/type/indexed/indexed-from-mapped-result.js

@@ -6,19 +6,20 @@ const index_1 = require("../mapped/index");
 const indexed_property_keys_1 = require("./indexed-property-keys");
 const index_2 = require("./index");
 // prettier-ignore
-function FromProperties(T, P, options) {
-    const Acc = {};
-    for (const K2 of Object.getOwnPropertyNames(P)) {
-        Acc[K2] = (0, index_2.Index)(T, (0, indexed_property_keys_1.IndexPropertyKeys)(P[K2]), options);
+function FromProperties(type, properties, options) {
+    const result = {};
+    for (const K2 of Object.getOwnPropertyNames(properties)) {
+        const keys = (0, indexed_property_keys_1.IndexPropertyKeys)(properties[K2]);
+        result[K2] = (0, index_2.Index)(type, keys, options);
     }
-    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
-function IndexFromMappedResult(T, R, options) {
-    const P = FromMappedResult(T, R, options);
-    return (0, index_1.MappedResult)(P);
+function IndexFromMappedResult(type, mappedResult, options) {
+    const properties = FromMappedResult(type, mappedResult, options);
+    return (0, index_1.MappedResult)(properties);
 }

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

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

package/build/cjs/type/indexed/indexed-property-keys.js

@@ -8,16 +8,16 @@ const index_1 = require("../template-literal/index");
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
-function FromTemplateLiteral(T) {
-    const R = (0, index_1.TemplateLiteralGenerate)(T);
-    return R.map(S => S.toString());
+function FromTemplateLiteral(templateLiteral) {
+    const result = (0, index_1.TemplateLiteralGenerate)(templateLiteral);
+    return result.map(S => S.toString());
 }
 // prettier-ignore
-function FromUnion(T) {
-    const Acc = [];
-    for (const L of T)
-        Acc.push(...IndexPropertyKeys(L));
-    return Acc;
+function FromUnion(type) {
+    const result = [];
+    for (const left of type)
+        result.push(...IndexPropertyKeys(left));
+    return result;
 }
 // prettier-ignore
 function FromLiteral(T) {
@@ -26,11 +26,11 @@ function FromLiteral(T) {
 }
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 // prettier-ignore
-function IndexPropertyKeys(T) {
-    return [...new Set(((0, kind_1.IsTemplateLiteral)(T) ? FromTemplateLiteral(T) :
-            (0, kind_1.IsUnion)(T) ? FromUnion(T.anyOf) :
-                (0, kind_1.IsLiteral)(T) ? FromLiteral(T.const) :
-                    (0, kind_1.IsNumber)(T) ? ['[number]'] :
-                        (0, kind_1.IsInteger)(T) ? ['[number]'] :
+function IndexPropertyKeys(type) {
+    return [...new Set(((0, kind_1.IsTemplateLiteral)(type) ? FromTemplateLiteral(type) :
+            (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf) :
+                (0, kind_1.IsLiteral)(type) ? FromLiteral(type.const) :
+                    (0, kind_1.IsNumber)(type) ? ['[number]'] :
+                        (0, kind_1.IsInteger)(type) ? ['[number]'] :
                             []))];
 }

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

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