@sinclair/typebox 0.33.22 → 0.34.1

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);
 }

package/build/esm/type/indexed/indexed-property-keys.d.mts

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

@@ -4,16 +4,16 @@ import { TemplateLiteralGenerate } from '../template-literal/index.mjs';
 // ------------------------------------------------------------------
 import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/kind.mjs';
 // prettier-ignore
-function FromTemplateLiteral(T) {
-    const R = TemplateLiteralGenerate(T);
-    return R.map(S => S.toString());
+function FromTemplateLiteral(templateLiteral) {
+    const result = 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) {
@@ -22,11 +22,11 @@ function FromLiteral(T) {
 }
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 // prettier-ignore
-export function IndexPropertyKeys(T) {
-    return [...new Set((IsTemplateLiteral(T) ? FromTemplateLiteral(T) :
-            IsUnion(T) ? FromUnion(T.anyOf) :
-                IsLiteral(T) ? FromLiteral(T.const) :
-                    IsNumber(T) ? ['[number]'] :
-                        IsInteger(T) ? ['[number]'] :
+export function IndexPropertyKeys(type) {
+    return [...new Set((IsTemplateLiteral(type) ? FromTemplateLiteral(type) :
+            IsUnion(type) ? FromUnion(type.anyOf) :
+                IsLiteral(type) ? FromLiteral(type.const) :
+                    IsNumber(type) ? ['[number]'] :
+                        IsInteger(type) ? ['[number]'] :
                             []))];
 }

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

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

package/build/esm/type/indexed/indexed.mjs

@@ -1,78 +1,91 @@
 import { CreateType } from '../create/type.mjs';
+import { Computed } from '../computed/index.mjs';
+import { Literal } from '../literal/index.mjs';
 import { Never } from '../never/index.mjs';
 import { IntersectEvaluated } from '../intersect/index.mjs';
 import { UnionEvaluated } from '../union/index.mjs';
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
 import { IndexPropertyKeys } from './indexed-property-keys.mjs';
 import { IndexFromMappedKey } from './indexed-from-mapped-key.mjs';
 import { IndexFromMappedResult } from './indexed-from-mapped-result.mjs';
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/kind.mjs';
+import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion, IsLiteralValue, IsRef } from '../guard/kind.mjs';
+import { IsArray as IsArrayValue } from '../guard/value.mjs';
 // prettier-ignore
-function FromRest(T, K) {
-    return T.map(L => IndexFromPropertyKey(L, K));
+function FromRest(types, key) {
+    return types.map(left => IndexFromPropertyKey(left, key));
 }
 // prettier-ignore
-function FromIntersectRest(T) {
-    return T.filter(L => !IsNever(L));
+function FromIntersectRest(types) {
+    return types.filter(left => !IsNever(left));
 }
 // prettier-ignore
-function FromIntersect(T, K) {
-    return (IntersectEvaluated(FromIntersectRest(FromRest(T, K))));
+function FromIntersect(types, key) {
+    return (IntersectEvaluated(FromIntersectRest(FromRest(types, key))));
 }
 // prettier-ignore
-function FromUnionRest(T) {
-    return (T.some(L => IsNever(L))
+function FromUnionRest(types) {
+    return (types.some(L => IsNever(L))
         ? []
-        : T);
+        : types);
 }
 // prettier-ignore
-function FromUnion(T, K) {
-    return (UnionEvaluated(FromUnionRest(FromRest(T, K))));
+function FromUnion(types, key) {
+    return (UnionEvaluated(FromUnionRest(FromRest(types, key))));
 }
 // prettier-ignore
-function FromTuple(T, K) {
-    return (K in T ? T[K] :
-        K === '[number]' ? UnionEvaluated(T) :
+function FromTuple(types, key) {
+    return (key === '[number]' ? UnionEvaluated(types) :
+        key in types ? types[key] :
             Never());
 }
 // prettier-ignore
-function FromArray(T, K) {
-    return (K === '[number]'
-        ? T
-        : Never());
+function FromArray(type, key) {
+    // ... ?
+    return (key === '[number]' ? type : Never());
 }
 // prettier-ignore
-function FromProperty(T, K) {
-    return (K in T ? T[K] : Never());
+function FromProperty(properties, key) {
+    return (key in properties ? properties[key] : Never());
 }
 // prettier-ignore
-export function IndexFromPropertyKey(T, K) {
-    return (IsIntersect(T) ? FromIntersect(T.allOf, K) :
-        IsUnion(T) ? FromUnion(T.anyOf, K) :
-            IsTuple(T) ? FromTuple(T.items ?? [], K) :
-                IsArray(T) ? FromArray(T.items, K) :
-                    IsObject(T) ? FromProperty(T.properties, K) :
+export function IndexFromPropertyKey(type, key) {
+    return (IsIntersect(type) ? FromIntersect(type.allOf, key) :
+        IsUnion(type) ? FromUnion(type.anyOf, key) :
+            IsTuple(type) ? FromTuple(type.items ?? [], key) :
+                IsArray(type) ? FromArray(type.items, key) :
+                    IsObject(type) ? FromProperty(type.properties, key) :
                         Never());
 }
 // prettier-ignore
-export function IndexFromPropertyKeys(T, K) {
-    return K.map(L => IndexFromPropertyKey(T, L));
+export function IndexFromPropertyKeys(type, propertyKeys) {
+    return propertyKeys.map(left => IndexFromPropertyKey(type, left));
 }
 // prettier-ignore
-function FromSchema(T, K) {
-    return (UnionEvaluated(IndexFromPropertyKeys(T, K)));
+function FromType(type, propertyKeys) {
+    const result = IndexFromPropertyKeys(type, propertyKeys);
+    return UnionEvaluated(result);
+}
+// prettier-ignore
+function UnionFromPropertyKeys(propertyKeys) {
+    const result = propertyKeys.reduce((result, key) => IsLiteralValue(key) ? [...result, Literal(key)] : result, []);
+    return UnionEvaluated(result);
 }
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index(T, K, options) {
-    // mapped-types
-    if (IsMappedResult(K))
-        return IndexFromMappedResult(T, K, options);
-    if (IsMappedKey(K))
-        return IndexFromMappedKey(T, K, options);
-    // prettier-ignore
-    return CreateType(IsSchema(K)
-        ? FromSchema(T, IndexPropertyKeys(K))
-        : FromSchema(T, K), options);
+// prettier-ignore
+export function Index(type, key, options) {
+    const typeKey = IsArrayValue(key) ? UnionFromPropertyKeys(key) : key;
+    const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
+    const isTypeRef = IsRef(type);
+    const isKeyRef = IsRef(key);
+    return (IsMappedResult(key) ? IndexFromMappedResult(type, key, options) :
+        IsMappedKey(key) ? IndexFromMappedKey(type, key, options) :
+            (isTypeRef && isKeyRef) ? Computed('Index', [type, typeKey], options) :
+                (!isTypeRef && isKeyRef) ? Computed('Index', [type, typeKey], options) :
+                    (isTypeRef && !isKeyRef) ? Computed('Index', [type, typeKey], options) :
+                        CreateType(FromType(type, propertyKeys), options));
 }

package/build/esm/type/intersect/intersect-evaluated.d.mts

@@ -3,11 +3,11 @@ import { type TNever } from '../never/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import type { TReadonly } from '../readonly/index.mjs';
 import { TIntersect, IntersectOptions } from './intersect-type.mjs';
-type TIsIntersectOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? TIsIntersectOptional<R> : false : true);
-type TRemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<TRemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromType<S> : T);
-type TRemoveOptionalFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromRest<R, [...Acc, TRemoveOptionalFromType<S>]> : TRemoveOptionalFromRest<R, [...Acc, L]> : Acc);
-type TResolveIntersect<T extends TSchema[]> = (TIsIntersectOptional<T> extends true ? TOptional<TIntersect<TRemoveOptionalFromRest<T>>> : TIntersect<TRemoveOptionalFromRest<T>>);
-export type TIntersectEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TResolveIntersect<T>);
+type TIsIntersectOptional<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<TSchema> ? TIsIntersectOptional<Right> : false : true);
+type TRemoveOptionalFromType<Type extends TSchema> = (Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType<Type>> : Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType<Type> : Type);
+type TRemoveOptionalFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromRest<Right, [...Result, TRemoveOptionalFromType<Type>]> : TRemoveOptionalFromRest<Right, [...Result, Left]> : Result);
+type TResolveIntersect<Types extends TSchema[]> = (TIsIntersectOptional<Types> extends true ? TOptional<TIntersect<TRemoveOptionalFromRest<Types>>> : TIntersect<TRemoveOptionalFromRest<Types>>);
+export type TIntersectEvaluated<Types extends TSchema[]> = (Types extends [TSchema] ? Types[0] : Types extends [] ? TNever : TResolveIntersect<Types>);
 /** `[Json]` Creates an evaluated Intersect type */
-export declare function IntersectEvaluated<T extends TSchema[], R = TIntersectEvaluated<T>>(T: [...T], options?: IntersectOptions): R;
+export declare function IntersectEvaluated<Types extends TSchema[], Result extends TSchema = TIntersectEvaluated<Types>>(types: [...Types], options?: IntersectOptions): Result;
 export {};

package/build/esm/type/intersect/intersect-evaluated.mjs

@@ -9,30 +9,30 @@ import { IntersectCreate } from './intersect-create.mjs';
 // ------------------------------------------------------------------
 import { IsOptional, IsTransform } from '../guard/kind.mjs';
 // prettier-ignore
-function IsIntersectOptional(T) {
-    return T.every(L => IsOptional(L));
+function IsIntersectOptional(types) {
+    return types.every(left => IsOptional(left));
 }
 // prettier-ignore
-function RemoveOptionalFromType(T) {
-    return (Discard(T, [OptionalKind]));
+function RemoveOptionalFromType(type) {
+    return (Discard(type, [OptionalKind]));
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T) {
-    return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L);
+function RemoveOptionalFromRest(types) {
+    return types.map(left => IsOptional(left) ? RemoveOptionalFromType(left) : left);
 }
 // prettier-ignore
-function ResolveIntersect(T, options) {
-    return (IsIntersectOptional(T)
-        ? Optional(IntersectCreate(RemoveOptionalFromRest(T), options))
-        : IntersectCreate(RemoveOptionalFromRest(T), options));
+function ResolveIntersect(types, options) {
+    return (IsIntersectOptional(types)
+        ? Optional(IntersectCreate(RemoveOptionalFromRest(types), options))
+        : IntersectCreate(RemoveOptionalFromRest(types), options));
 }
 /** `[Json]` Creates an evaluated Intersect type */
-export function IntersectEvaluated(T, options = {}) {
-    if (T.length === 0)
+export function IntersectEvaluated(types, options = {}) {
+    if (types.length === 1)
+        return CreateType(types[0], options);
+    if (types.length === 0)
         return Never(options);
-    if (T.length === 1)
-        return CreateType(T[0], options);
-    if (T.some((schema) => IsTransform(schema)))
+    if (types.some((schema) => IsTransform(schema)))
         throw new Error('Cannot intersect transform types');
-    return ResolveIntersect(T, options);
+    return ResolveIntersect(types, options);
 }

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

@@ -1,6 +1,6 @@
 import type { TSchema } from '../schema/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { TIntersect, IntersectOptions } from './intersect-type.mjs';
-export type Intersect<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TIntersect<T>);
+export type Intersect<Types extends TSchema[]> = (Types extends [TSchema] ? Types[0] : Types extends [] ? TNever : TIntersect<Types>);
 /** `[Json]` Creates an evaluated Intersect type */
-export declare function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T>;
+export declare function Intersect<Types extends TSchema[]>(types: [...Types], options?: IntersectOptions): Intersect<Types>;

package/build/esm/type/intersect/intersect.mjs

@@ -6,12 +6,12 @@ import { IntersectCreate } from './intersect-create.mjs';
 // ------------------------------------------------------------------
 import { IsTransform } from '../guard/kind.mjs';
 /** `[Json]` Creates an evaluated Intersect type */
-export function Intersect(T, options) {
-    if (T.length === 0)
+export function Intersect(types, options) {
+    if (types.length === 1)
+        return CreateType(types[0], options);
+    if (types.length === 0)
         return Never(options);
-    if (T.length === 1)
-        return CreateType(T[0], options);
-    if (T.some((schema) => IsTransform(schema)))
+    if (types.some((schema) => IsTransform(schema)))
         throw new Error('Cannot intersect transform types');
-    return IntersectCreate(T, options);
+    return IntersectCreate(types, options);
 }

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

@@ -2,11 +2,11 @@ import type { SchemaOptions } from '../schema/index.mjs';
 import type { Ensure, Evaluate } from '../helpers/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
-import { type TKeyOf } from './keyof.mjs';
-type TFromProperties<K extends TProperties> = ({
-    [K2 in keyof K]: TKeyOf<K[K2]>;
+import { type TKeyOfFromType } from './keyof.mjs';
+type TFromProperties<Properties extends TProperties> = ({
+    [K2 in keyof Properties]: TKeyOfFromType<Properties[K2]>;
 });
-type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
-export type TKeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
-export declare function KeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options?: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<MappedResult extends TMappedResult> = (Evaluate<TFromProperties<MappedResult['properties']>>);
+export type TKeyOfFromMappedResult<MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult<MappedResult>> = (Ensure<TMappedResult<Properties>>);
+export declare function KeyOfFromMappedResult<MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult<MappedResult>>(mappedResult: MappedResult, options?: SchemaOptions): TMappedResult<Properties>;
 export {};

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

@@ -2,18 +2,18 @@ import { MappedResult } from '../mapped/index.mjs';
 import { KeyOf } from './keyof.mjs';
 import { Clone } from '../clone/value.mjs';
 // prettier-ignore
-function FromProperties(K, options) {
-    const Acc = {};
-    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
-        Acc[K2] = KeyOf(K[K2], Clone(options));
-    return Acc;
+function FromProperties(properties, options) {
+    const result = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+        result[K2] = KeyOf(properties[K2], Clone(options));
+    return result;
 }
 // prettier-ignore
-function FromMappedResult(R, options) {
-    return FromProperties(R.properties, options);
+function FromMappedResult(mappedResult, options) {
+    return FromProperties(mappedResult.properties, options);
 }
 // prettier-ignore
-export function KeyOfFromMappedResult(R, options) {
-    const P = FromMappedResult(R, options);
-    return MappedResult(P);
+export function KeyOfFromMappedResult(mappedResult, options) {
+    const properties = FromMappedResult(mappedResult, options);
+    return MappedResult(properties);
 }

package/build/esm/type/keyof/keyof-property-keys.d.mts

@@ -7,18 +7,18 @@ import type { TTuple } from '../tuple/index.mjs';
 import type { TArray } from '../array/index.mjs';
 import type { TObject, TProperties } from '../object/index.mjs';
 import { type TSetUnionMany, type TSetIntersectMany } from '../sets/index.mjs';
-type TFromRest<T extends TSchema[], Acc extends PropertyKey[][] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TKeyOfPropertyKeys<L>]> : Acc);
-type TFromIntersect<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetUnionMany<C>> = R;
-type TFromUnion<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetIntersectMany<C>> = R;
-type TFromTuple<T extends TSchema[], I extends string = ZeroString, Acc extends PropertyKey[] = []> = T extends [infer _ extends TSchema, ...infer R extends TSchema[]] ? TFromTuple<R, TIncrement<I>, [...Acc, I]> : Acc;
+type TFromRest<Types extends TSchema[], Result extends PropertyKey[][] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Result, TKeyOfPropertyKeys<L>]> : Result);
+type TFromIntersect<Types extends TSchema[], PropertyKeysArray extends PropertyKey[][] = TFromRest<Types>, PropertyKeys extends PropertyKey[] = TSetUnionMany<PropertyKeysArray>> = PropertyKeys;
+type TFromUnion<Types extends TSchema[], PropertyKeysArray extends PropertyKey[][] = TFromRest<Types>, PropertyKeys extends PropertyKey[] = TSetIntersectMany<PropertyKeysArray>> = PropertyKeys;
+type TFromTuple<Types extends TSchema[], Indexer extends string = ZeroString, Acc extends PropertyKey[] = []> = Types extends [infer _ extends TSchema, ...infer R extends TSchema[]] ? TFromTuple<R, TIncrement<Indexer>, [...Acc, Indexer]> : Acc;
 type TFromArray<_ extends TSchema> = ([
     '[number]'
 ]);
-type TFromProperties<T extends TProperties> = (UnionToTuple<keyof T>);
-export type TKeyOfPropertyKeys<T extends TSchema> = (T extends TRecursive<infer S> ? TKeyOfPropertyKeys<S> : T extends TIntersect<infer S> ? TFromIntersect<S> : T extends TUnion<infer S> ? TFromUnion<S> : T extends TTuple<infer S> ? TFromTuple<S> : T extends TArray<infer S> ? TFromArray<S> : T extends TObject<infer S> ? TFromProperties<S> : [
+type TFromProperties<Properties extends TProperties> = (UnionToTuple<keyof Properties>);
+export type TKeyOfPropertyKeys<Type extends TSchema> = (Type extends TRecursive<infer Type extends TSchema> ? TKeyOfPropertyKeys<Type> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Type> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Properties> : [
 ]);
 /** Returns a tuple of PropertyKeys derived from the given TSchema. */
-export declare function KeyOfPropertyKeys<T extends TSchema>(T: T): TKeyOfPropertyKeys<T>;
+export declare function KeyOfPropertyKeys<Type extends TSchema>(type: Type): TKeyOfPropertyKeys<Type>;
 /** Returns a regular expression pattern derived from the given TSchema */
 export declare function KeyOfPattern(schema: TSchema): string;
 export {};

package/build/esm/type/keyof/keyof-property-keys.mjs

@@ -4,27 +4,27 @@ import { SetUnionMany, SetIntersectMany } from '../sets/index.mjs';
 // ------------------------------------------------------------------
 import { IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsRecord } from '../guard/kind.mjs';
 // prettier-ignore
-function FromRest(T) {
-    const Acc = [];
-    for (const L of T)
-        Acc.push(KeyOfPropertyKeys(L));
-    return Acc;
+function FromRest(types) {
+    const result = [];
+    for (const L of types)
+        result.push(KeyOfPropertyKeys(L));
+    return result;
 }
 // prettier-ignore
-function FromIntersect(T) {
-    const C = FromRest(T);
-    const R = SetUnionMany(C);
-    return R;
+function FromIntersect(types) {
+    const propertyKeysArray = FromRest(types);
+    const propertyKeys = SetUnionMany(propertyKeysArray);
+    return propertyKeys;
 }
 // prettier-ignore
-function FromUnion(T) {
-    const C = FromRest(T);
-    const R = SetIntersectMany(C);
-    return R;
+function FromUnion(types) {
+    const propertyKeysArray = FromRest(types);
+    const propertyKeys = SetIntersectMany(propertyKeysArray);
+    return propertyKeys;
 }
 // prettier-ignore
-function FromTuple(T) {
-    return T.map((_, I) => I.toString());
+function FromTuple(types) {
+    return types.map((_, indexer) => indexer.toString());
 }
 // prettier-ignore
 function FromArray(_) {
@@ -50,13 +50,13 @@ function FromPatternProperties(patternProperties) {
 }
 /** Returns a tuple of PropertyKeys derived from the given TSchema. */
 // prettier-ignore
-export function KeyOfPropertyKeys(T) {
-    return (IsIntersect(T) ? FromIntersect(T.allOf) :
-        IsUnion(T) ? FromUnion(T.anyOf) :
-            IsTuple(T) ? FromTuple(T.items ?? []) :
-                IsArray(T) ? FromArray(T.items) :
-                    IsObject(T) ? FromProperties(T.properties) :
-                        IsRecord(T) ? FromPatternProperties(T.patternProperties) :
+export function KeyOfPropertyKeys(type) {
+    return (IsIntersect(type) ? FromIntersect(type.allOf) :
+        IsUnion(type) ? FromUnion(type.anyOf) :
+            IsTuple(type) ? FromTuple(type.items ?? []) :
+                IsArray(type) ? FromArray(type.items) :
+                    IsObject(type) ? FromProperties(type.properties) :
+                        IsRecord(type) ? FromPatternProperties(type.patternProperties) :
                             []);
 }
 // ----------------------------------------------------------------

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

@@ -4,13 +4,18 @@ import type { TMappedResult } from '../mapped/index.mjs';
 import type { SchemaOptions } from '../schema/index.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TNumber } from '../number/index.mjs';
+import { TComputed } from '../computed/index.mjs';
+import { type TRef } from '../ref/index.mjs';
 import { type TKeyOfPropertyKeys } from './keyof-property-keys.mjs';
 import { type TUnionEvaluated } from '../union/index.mjs';
 import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
-export type TKeyOfPropertyKeysToRest<T extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? L extends '[number]' ? TKeyOfPropertyKeysToRest<R, [...Acc, TNumber]> : TKeyOfPropertyKeysToRest<R, [...Acc, TLiteral<Assert<L, TLiteralValue>>]> : Acc);
-export declare function KeyOfPropertyKeysToRest<T extends PropertyKey[]>(T: [...T]): TKeyOfPropertyKeysToRest<T>;
-export type TKeyOf<T extends TSchema, K extends PropertyKey[] = TKeyOfPropertyKeys<T>, S extends TSchema[] = TKeyOfPropertyKeysToRest<K>, U = TUnionEvaluated<S>> = (Ensure<U>);
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<'KeyOf', [TComputed<Target, Parameters>]>>;
+type TFromRef<Ref extends string> = Ensure<TComputed<'KeyOf', [TRef<Ref>]>>;
+/** `[Internal]` Used by KeyOfFromMappedResult */
+export type TKeyOfFromType<Type extends TSchema, PropertyKeys extends PropertyKey[] = TKeyOfPropertyKeys<Type>, PropertyKeyTypes extends TSchema[] = TKeyOfPropertyKeysToRest<PropertyKeys>, Result = TUnionEvaluated<PropertyKeyTypes>> = Ensure<Result>;
+export type TKeyOfPropertyKeysToRest<PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (PropertyKeys extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? L extends '[number]' ? TKeyOfPropertyKeysToRest<R, [...Result, TNumber]> : TKeyOfPropertyKeysToRest<R, [...Result, TLiteral<Assert<L, TLiteralValue>>]> : Result);
+export declare function KeyOfPropertyKeysToRest<PropertyKeys extends PropertyKey[]>(propertyKeys: [...PropertyKeys]): TKeyOfPropertyKeysToRest<PropertyKeys>;
+export type TKeyOf<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 TMappedResult ? TKeyOfFromMappedResult<Type> : TKeyOfFromType<Type>);
 /** `[Json]` Creates a KeyOf type */
-export declare function KeyOf<T extends TMappedResult>(T: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
-/** `[Json]` Creates a KeyOf type */
-export declare function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>;
+export declare function KeyOf<Type extends TSchema>(type: Type, options?: SchemaOptions): TKeyOf<Type>;
+export {};