diff --git a/example/index.ts b/example/index.ts
index 11348e922..b351903b7 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -2,34 +2,47 @@ import { TypeSystem } from '@sinclair/typebox/system'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
 import { Parse, StaticParseAsType } from '@sinclair/typebox/syntax'
-import { Type, TypeGuard, Kind, Static, TSchema } from '@sinclair/typebox'
+import { Type, Index, TypeGuard, Kind, Static, TSchema } from '@sinclair/typebox'
 
-// KindGuard.IsLiteralValue
-
-// New Types:
+// Computed Types:
 //  - Awaited (Computed)
 //  - Partial (Computed)
 //  - Pick (Computed)
 //  - Omit (Computed)
 //  - Required (Computed)
-//  - KeyOf
+//  - KeyOf (Computed)
+//  - Index (Computed ... nearly)
+//  - Record (...)
+
+const T = Type.Object({
+  x: Type.Number(),
+  y: Type.Number(),
+  z: Type.Number(),
+})
+
+
+
+// const Module = Parse(`module {
+
+//   type A = {
+//     x: number
+//     y: number
+//     z: number
+//   }
+
+//   type K = A[keyof A]
+  
+// }`)
 
 const Module = Type.Module({
   A: Type.Object({
     x: Type.Number(),
-    y: Type.Number(),
+    y: Type.String(),
+    z: Type.Boolean(),
   }),
-  T: Type.KeyOf(Type.Ref('A')),
+  K: Type.Index(Type.Ref('A'), Type.KeyOf(Type.Ref('A')))
 })
 
-const A = Module.Import('A')
-const T = Module.Import('T')
-
-function test(value: Static<typeof T>) {}
-
-console.dir(T, { depth: 100 })
-
-type A = Static<typeof A>
-type T = Static<typeof T>
+const K = Module.Import('K')
 
-// Ok(T, { nodes: [{ nodes: [{ nodes: [] }, { nodes: [] }] }] })
+type K = Static<typeof K>
diff --git a/src/syntax/runtime.ts b/src/syntax/runtime.ts
index 15001ee48..82db79005 100644
--- a/src/syntax/runtime.ts
+++ b/src/syntax/runtime.ts
@@ -324,11 +324,12 @@ const FactorIndexArray = (Type: Types.TSchema, IndexArray: unknown[]): Types.TSc
   const [Left, Right] = DestructureRight(IndexArray) as [unknown[], Types.TSchema[]]
   return (
     !Types.ValueGuard.IsUndefined(Right) ? (
-      Right.length === 1 ? Types.Index(FactorIndexArray(Type, Left), Right[0]) :
+      // note: Indexed types require reimplementation to replace `[number]` indexers
+      Right.length === 1 ? Types.Index(FactorIndexArray(Type, Left), Right[0]) as never :
       Right.length === 0 ? Types.Array(FactorIndexArray(Type, Left)) :
       Types.Never()
     ) : Type
-  )
+  ) 
 }
 // prettier-ignore
 const FactorMapping = (KeyOf: boolean, Type: Types.TSchema, IndexArray: unknown[], Extends: Types.TSchema[]) => {
diff --git a/src/type/array/array.ts b/src/type/array/array.ts
index 388ba25d7..dc29a1858 100644
--- a/src/type/array/array.ts
+++ b/src/type/array/array.ts
@@ -54,6 +54,6 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
   items: T
 }
 /** `[Json]` Creates an Array type */
-export function Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T> {
+export function Array<Type extends TSchema>(items: Type, options?: ArrayOptions): TArray<Type> {
   return CreateType({ [Kind]: 'Array', type: 'array', items }, options) as never
 }
diff --git a/src/type/indexed/indexed-from-mapped-key.ts b/src/type/indexed/indexed-from-mapped-key.ts
index 4251cea89..b66cf5113 100644
--- a/src/type/indexed/indexed-from-mapped-key.ts
+++ b/src/type/indexed/indexed-from-mapped-key.ts
@@ -37,68 +37,53 @@ import { Clone } from '../clone/value'
 // MappedIndexPropertyKey
 // ------------------------------------------------------------------
 // prettier-ignore
-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]>
 }
 // prettier-ignore
-function MappedIndexPropertyKey<
-  T extends TSchema, 
-  K extends PropertyKey
->(T: T, K: K, options?: SchemaOptions): TMappedIndexPropertyKey<T, K> {
-  return { [K]: Index(T, [K], Clone(options)) } as never
+function MappedIndexPropertyKey<Type extends TSchema, Key extends PropertyKey
+>(type: Type, key: Key, options?: SchemaOptions): TMappedIndexPropertyKey<Type, Key> {
+  return { [key]: Index(type, [key], Clone(options)) } as never
 }
 // ------------------------------------------------------------------
 // MappedIndexPropertyKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-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 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
 )
 // prettier-ignore
-function MappedIndexPropertyKeys<
-  T extends TSchema, 
-  K extends PropertyKey[]
->(T: T, K: [...K], options?: SchemaOptions): TMappedIndexPropertyKeys<T, K> {
-  return K.reduce((Acc, L) => {
-    return { ...Acc, ...MappedIndexPropertyKey(T, L, options) }
+function MappedIndexPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TMappedIndexPropertyKeys<Type, PropertyKeys> {
+  return propertyKeys.reduce((result, left) => {
+    return { ...result, ...MappedIndexPropertyKey(type, left, options) }
   }, {} as TProperties) as never
 }
 // ------------------------------------------------------------------
 // MappedIndexProperties
 // ------------------------------------------------------------------
 // prettier-ignore
-type TMappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<
-  TMappedIndexPropertyKeys<T, K['keys']>
+type TMappedIndexProperties<Type extends TSchema, MappedKey extends TMappedKey> = Evaluate<
+  TMappedIndexPropertyKeys<Type, MappedKey['keys']>
 >
 // prettier-ignore
-function MappedIndexProperties<
-  T extends TSchema, 
-  K extends TMappedKey
->(T: T, K: K, options?: SchemaOptions): TMappedIndexProperties<T, K> {
-  return MappedIndexPropertyKeys(T, K.keys, options) as never
+function MappedIndexProperties<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedIndexProperties<Type, MappedKey> {
+  return MappedIndexPropertyKeys(type, mappedKey.keys, options) as never
 }
 // ------------------------------------------------------------------
 // TIndexFromMappedKey
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TIndexFromMappedKey<
-  T extends TSchema, 
-  K extends TMappedKey, 
-  P extends TProperties = TMappedIndexProperties<T, K>
+export type TIndexFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, 
+  Properties extends TProperties = TMappedIndexProperties<Type, MappedKey>
 > = (
-  Ensure<TMappedResult<P>>
+  Ensure<TMappedResult<Properties>>
 )
 // prettier-ignore
-export function IndexFromMappedKey<
-  T extends TSchema, 
-  K extends TMappedKey, 
-  P extends TProperties = TMappedIndexProperties<T, K>
->(T: T, K: K, options?: SchemaOptions): TMappedResult<P> {
-  const P = MappedIndexProperties(T, K, options)
-  return MappedResult(P) as never
+export function IndexFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, 
+  Properties extends TProperties = TMappedIndexProperties<Type, MappedKey>
+>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedResult<Properties> {
+  const properties = MappedIndexProperties(type, mappedKey, options)
+  return MappedResult(properties) as never
 }
diff --git a/src/type/indexed/indexed-from-mapped-result.ts b/src/type/indexed/indexed-from-mapped-result.ts
index d23fa750d..136e7a1ba 100644
--- a/src/type/indexed/indexed-from-mapped-result.ts
+++ b/src/type/indexed/indexed-from-mapped-result.ts
@@ -37,21 +37,22 @@ import { Index, type TIndex } from './index'
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromProperties<
-  T extends TSchema,
-  P extends TProperties
+  Type extends TSchema,
+  Properties extends TProperties
 > = (
-  { [K2 in keyof P]: TIndex<T, TIndexPropertyKeys<P[K2]>> }   
+  { [K2 in keyof Properties]: TIndex<Type, TIndexPropertyKeys<Properties[K2]>> }   
 )
 // prettier-ignore
 function FromProperties<
-  T extends TSchema,
-  P extends TProperties
->(T: T, P: P, options?: SchemaOptions): TFromProperties<T, P> {
-  const Acc = {} as Record<PropertyKey, TSchema>
-  for(const K2 of Object.getOwnPropertyNames(P)) {
-    Acc[K2] = Index(T, IndexPropertyKeys(P[K2]), options)
+  Type extends TSchema,
+  Properties extends TProperties
+>(type: Type, properties: Properties, options?: SchemaOptions): TFromProperties<Type, Properties> {
+  const result = {} as Record<PropertyKey, TSchema>
+  for(const K2 of Object.getOwnPropertyNames(properties)) {
+    const keys = IndexPropertyKeys(properties[K2])
+    result[K2] = Index(type, keys, options) as never
   }
-  return Acc as never
+  return result as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult
diff --git a/src/type/indexed/indexed-property-keys.ts b/src/type/indexed/indexed-property-keys.ts
index dcb60fad7..ad73541e4 100644
--- a/src/type/indexed/indexed-property-keys.ts
+++ b/src/type/indexed/indexed-property-keys.ts
@@ -41,38 +41,40 @@ import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../g
 // FromTemplateLiteral
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemplateLiteralGenerate<T>> = (R)
+type TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, 
+  Result extends string[] = TTemplateLiteralGenerate<TemplateLiteral>
+> = Result
 // prettier-ignore
-function FromTemplateLiteral<T extends TTemplateLiteral>(T: T): TFromTemplateLiteral<T> {
-  const R = TemplateLiteralGenerate(T) as string[]
-  return R.map(S => S.toString()) as never
+function FromTemplateLiteral<TemplateLiteral extends TTemplateLiteral>(templateLiteral: TemplateLiteral): TFromTemplateLiteral<TemplateLiteral> {
+  const result = TemplateLiteralGenerate(templateLiteral) as string[]
+  return result.map(S => S.toString()) as never
 }
 // ------------------------------------------------------------------
 // FromUnion
 // ------------------------------------------------------------------
 // prettier-ignore
-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 TFromUnion<Types extends TSchema[], Result extends string[] = []> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] 
+    ? TFromUnion<Right, [...Result, ...TIndexPropertyKeys<Left>]>
+    : Result
 )
 // prettier-ignore
-function FromUnion<T extends TSchema[]>(T: T): TFromUnion<T> {
-  const Acc = [] as string[]
-  for(const L of T) Acc.push(...IndexPropertyKeys(L))
-  return Acc as never
+function FromUnion<Type extends TSchema[]>(type: Type): TFromUnion<Type> {
+  const result = [] as string[]
+  for(const left of type) result.push(...IndexPropertyKeys(left))
+  return result as never
 }
 // ------------------------------------------------------------------
 // FromLiteral
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromLiteral<T extends TLiteralValue> = (
-  T extends PropertyKey 
-    ? [`${T}`] 
+type TFromLiteral<LiteralValue extends TLiteralValue> = (
+  LiteralValue extends PropertyKey 
+    ? [`${LiteralValue}`] 
     : []
 )
 // prettier-ignore
-function FromLiteral<T extends TLiteralValue>(T: T): TFromLiteral<T> {
+function FromLiteral<LiteralValue extends TLiteralValue>(T: LiteralValue): TFromLiteral<LiteralValue> {
   return (
     [(T as string).toString()] // TS 5.4 observes TLiteralValue as not having a toString()
   ) as never
@@ -81,23 +83,23 @@ function FromLiteral<T extends TLiteralValue>(T: T): TFromLiteral<T> {
 // IndexedKeyResolve
 // ------------------------------------------------------------------
 // prettier-ignore
-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]'] :
+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 */
 // prettier-ignore
-export function IndexPropertyKeys<T extends TSchema>(T: T): TIndexPropertyKeys<T> {
+export function IndexPropertyKeys<Type extends TSchema>(type: Type): TIndexPropertyKeys<Type> {
   return [...new Set<string>((
-    IsTemplateLiteral(T) ? FromTemplateLiteral(T) :
-    IsUnion(T) ? FromUnion(T.anyOf) :
-    IsLiteral(T) ? FromLiteral(T.const) :
-    IsNumber(T) ? ['[number]'] : 
-    IsInteger(T) ? ['[number]'] :
+    IsTemplateLiteral(type) ? FromTemplateLiteral(type) :
+    IsUnion(type) ? FromUnion(type.anyOf) :
+    IsLiteral(type) ? FromLiteral(type.const) :
+    IsNumber(type) ? ['[number]'] : 
+    IsInteger(type) ? ['[number]'] :
     []
   ))] as never
 }
diff --git a/src/type/indexed/indexed.ts b/src/type/indexed/indexed.ts
index 6de947666..656a19cc5 100644
--- a/src/type/indexed/indexed.ts
+++ b/src/type/indexed/indexed.ts
@@ -28,62 +28,93 @@ THE SOFTWARE.
 
 import { CreateType } from '../create/type'
 import { type TSchema, SchemaOptions } from '../schema/index'
+import { Computed, type TComputed } from '../computed/index'
+import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
 import { type TObject, type TProperties } from '../object/index'
-import { type Assert } from '../helpers/index'
+import { type Ensure, type Assert } from '../helpers/index'
 import { Never, type TNever } from '../never/index'
 import { type TRecursive } from '../recursive/index'
 import { type TIntersect } from '../intersect/index'
 import { TMappedResult, type TMappedKey } from '../mapped/index'
-import { type TUnion } from '../union/index'
+import { Union, type TUnion } from '../union/index'
 import { type TTuple } from '../tuple/index'
 import { type TArray } from '../array/index'
+import { Ref, type TRef } from '../ref/index'
 import { IntersectEvaluated, type TIntersectEvaluated } from '../intersect/index'
 import { UnionEvaluated, type TUnionEvaluated } from '../union/index'
 
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
 import { IndexPropertyKeys, type TIndexPropertyKeys } from './indexed-property-keys'
 import { IndexFromMappedKey, type TIndexFromMappedKey } from './indexed-from-mapped-key'
 import { IndexFromMappedResult, type TIndexFromMappedResult } from './indexed-from-mapped-result'
+
+// ------------------------------------------------------------------
+// KindGuard
 // ------------------------------------------------------------------
-// TypeGuard
+import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion, IsLiteralValue, IsRef, IsComputed } from '../guard/kind'
+import { IsArray as IsArrayValue } from '../guard/value'
+
+// ------------------------------------------------------------------
+// FromComputed
 // ------------------------------------------------------------------
-import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/kind'
+// prettier-ignore
+// type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<
+//   TComputed<'Partial', [TComputed<Target, Parameters>]>
+// >
+// // prettier-ignore
+// function FromComputed<Target extends string, Parameters extends TSchema[]>(target: Target, parameters: Parameters): TFromComputed<Target, Parameters> {
+//   return Computed('Partial', [Computed(target, parameters)]) as never
+// }
+// // ------------------------------------------------------------------
+// // FromRef
+// // ------------------------------------------------------------------
+// // prettier-ignore
+// type TFromRef<Ref extends string> = Ensure<
+//   TComputed<'Partial', [TRef<Ref>]>
+// >
+// // prettier-ignore
+// function FromRef<Ref extends string>($ref: Ref): TFromRef<Ref> {
+//   return Computed('Partial', [Ref($ref)]) as never
+// }
 
 // ------------------------------------------------------------------
 // FromRest
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (
+type TFromRest<T extends TSchema[], K extends PropertyKey, Result extends TSchema[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, K, [...Acc, Assert<TIndexFromPropertyKey<L, K>, TSchema>]>
-    : Acc
+    ? TFromRest<R, K, [...Result, Assert<TIndexFromPropertyKey<L, K>, TSchema>]>
+    : Result
 )
 // prettier-ignore
-function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromRest<T, K> {
-  return T.map(L => IndexFromPropertyKey(L, K)) as never
+function FromRest<Types extends TSchema[], K extends PropertyKey>(types: [...Types], key: K): TFromRest<Types, K> {
+  return types.map(left => IndexFromPropertyKey(left, key)) as never
 }
 // ------------------------------------------------------------------
 // FromIntersectRest
 // ------------------------------------------------------------------
 // prettier-ignore
-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 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
 )
 // prettier-ignore
-function FromIntersectRest<T extends TSchema[]>(T: [...T]): TFromIntersectRest<T> {
-  return T.filter(L => !IsNever(L)) as never
+function FromIntersectRest<Types extends TSchema[]>(types: [...Types]): TFromIntersectRest<Types> {
+  return types.filter(left => !IsNever(left)) as never
 }
 // prettier-ignore
-type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (
-  TIntersectEvaluated<TFromIntersectRest<TFromRest<T, K>>>
+type TFromIntersect<Types extends TSchema[], Key extends PropertyKey> = (
+  TIntersectEvaluated<TFromIntersectRest<TFromRest<Types, Key>>>
 )
 // prettier-ignore
-function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromIntersect<T, K> {
+function FromIntersect<Types extends TSchema[], Key extends PropertyKey>(types: [...Types], key: Key): TFromIntersect<Types, Key> {
   return (
-    IntersectEvaluated(FromIntersectRest(FromRest(T as TSchema[], K)))
+    IntersectEvaluated(FromIntersectRest(FromRest(types as TSchema[], key)))
   ) as never
 }
 // ------------------------------------------------------------------
@@ -110,47 +141,51 @@ function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K:
 //
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromUnionRest<T extends TSchema[], Acc extends TSchema[] = []> = 
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? L extends TNever 
+type TFromUnionRest<Types extends TSchema[], Result extends TSchema[] = []> = 
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+    ? Left extends TNever 
       ? []
-      : TFromUnionRest<R, [L, ...Acc]>
-    : Acc
+      : TFromUnionRest<Right, [Left, ...Result]>
+    : Result
 // prettier-ignore
-function FromUnionRest<T extends TSchema[]>(T: [...T]): TFromUnionRest<T> {
+function FromUnionRest<Types extends TSchema[]>(types: [...Types]): TFromUnionRest<Types> {
   return (
-    T.some(L => IsNever(L)) 
+    types.some(L => IsNever(L)) 
       ? [] 
-      : T 
+      : types 
   ) as never
 }
 // ------------------------------------------------------------------
 // FromUnion
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromUnion<T extends TSchema[], K extends PropertyKey> = (
-  TUnionEvaluated<TFromUnionRest<TFromRest<T, K>>>
+type TFromUnion<Types extends TSchema[], Key extends PropertyKey> = (
+  TUnionEvaluated<TFromUnionRest<TFromRest<Types, Key>>>
 )
 // prettier-ignore
-function FromUnion<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromUnion<T, K> {
+function FromUnion<Types extends TSchema[], Key extends PropertyKey>(types: [...Types], key: Key): TFromUnion<Types, Key> {
   return (
-    UnionEvaluated(FromUnionRest(FromRest(T as TSchema[], K)))
+    UnionEvaluated(FromUnionRest(FromRest(types as TSchema[], key)))
   ) as never
 }
 // ------------------------------------------------------------------
 // FromTuple
 // ------------------------------------------------------------------
+
 // prettier-ignore
-type TFromTuple<T extends TSchema[], K extends PropertyKey> = (
-  K extends keyof T ? T[K] : 
-  K extends '[number]' ? TUnionEvaluated<T> : 
-  TNever
-)
+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
 // prettier-ignore
-function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TFromTuple<T, K>  {
+function FromTuple<Types extends TSchema[], Key extends PropertyKey>(types: [...Types], key: Key): TFromTuple<Types, Key>  {
   return (
-    K in T ? T[K as number] : 
-    K === '[number]' ? UnionEvaluated(T) : 
+    key === '[number]' ? UnionEvaluated(types) : 
+    key in types ? types[key as number] : 
     Never()
   ) as never
 }
@@ -158,62 +193,54 @@ function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K):
 // FromArray
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromArray<T extends TSchema, K extends PropertyKey> = (
-  K extends '[number]' 
-    ? T 
-    : TNever
+type TFromArray<Type extends TSchema, Key extends PropertyKey> = (
+  Key extends '[number]' ? Type : TNever
 )
 // prettier-ignore
-function FromArray<T extends TSchema, K extends PropertyKey>(T: T, K: K): TFromArray<T, K>  {
-  return (
-    K === '[number]' 
-      ? T 
-      : Never()
-  ) as never
+function FromArray<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key): TFromArray<Type, Key> {
+  // ... ?
+  return (key === '[number]' ? type : Never()) as never
 }
 // ------------------------------------------------------------------
 // FromProperty
 // ------------------------------------------------------------------
-type AssertPropertyKey<T> = Assert<T, string | number>
+type AssertPropertyKey<T extends unknown> = Assert<T, string | number>
 
 // prettier-ignore
-type TFromProperty<
-  T extends TProperties, 
-  K extends PropertyKey,
-> = (
+type TFromProperty<Properties extends TProperties, Key extends PropertyKey, Result extends TSchema = (
   // evaluate for string keys
-  K extends keyof T 
-    ? T[K] 
+  Key extends keyof Properties 
+    ? Properties[Key] 
     // evaluate for numeric keys
-    : `${AssertPropertyKey<K>}` extends `${AssertPropertyKey<keyof T>}` 
-      ? T[AssertPropertyKey<K>]
+    : `${AssertPropertyKey<Key>}` extends `${AssertPropertyKey<keyof Properties>}` 
+      ? Properties[AssertPropertyKey<Key>]
       : TNever
-)
+)> = Result
 // prettier-ignore
-function FromProperty<T extends TProperties, K extends PropertyKey>(T: T, K: K): TFromProperty<T, K> {
-  return (K in T ? T[K as string] : Never()) as never
+function FromProperty<Properties extends TProperties, Key extends PropertyKey>(properties: Properties, key: Key): TFromProperty<Properties, Key> {
+  return (key in properties ? properties[key as string] : Never()) as never
 }
 // ------------------------------------------------------------------
 // FromKey
 // ------------------------------------------------------------------
 // prettier-ignore
-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> :
+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
 )
 // prettier-ignore
-export function IndexFromPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): TIndexFromPropertyKey<T, K> {
+export function IndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key): TIndexFromPropertyKey<Type, Key> {
   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) :
+    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()
   ) as never
 }
@@ -221,52 +248,81 @@ export function IndexFromPropertyKey<T extends TSchema, K extends PropertyKey>(T
 // FromKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-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 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
 )
 // prettier-ignore
-export function IndexFromPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TIndexFromPropertyKeys<T, K> {
-  return K.map(L => IndexFromPropertyKey(T, L)) as never
+export function IndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): TIndexFromPropertyKeys<Type, PropertyKeys> {
+  return propertyKeys.map(left => IndexFromPropertyKey(type, left)) as never
 }
 // ------------------------------------------------------------------
 // FromSchema
 // ------------------------------------------------------------------
 // prettier-ignore
-type FromSchema<T extends TSchema, K extends PropertyKey[]> = (
-  TUnionEvaluated<TIndexFromPropertyKeys<T, K>>
+type TFromType<Type extends TSchema, PropertyKeys extends PropertyKey[], 
+  Result extends TSchema[] = TIndexFromPropertyKeys<Type, PropertyKeys>,
+> = TUnionEvaluated<Result>
+// prettier-ignore
+function FromType<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): TFromType<Type, PropertyKeys> {
+  const result = IndexFromPropertyKeys(type, propertyKeys as PropertyKey[])
+  return UnionEvaluated(result) as never
+}
+// ------------------------------------------------------------------
+// UnionFromPropertyKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+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>
 )
 // prettier-ignore
-function FromSchema<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromSchema<T, K> {
-  return (
-    UnionEvaluated(IndexFromPropertyKeys(T, K as PropertyKey[]))
-  ) as never
+function UnionFromPropertyKeys<PropertyKeys extends PropertyKey[]>(propertyKeys: PropertyKeys): TUnionFromPropertyKeys<PropertyKeys> {
+  const result = propertyKeys.reduce((result, key) => IsLiteralValue(key) ? [...result, Literal(key)]: result, [] as TLiteral[])
+  return UnionEvaluated(result) as never
 }
 // ------------------------------------------------------------------
 // TIndex
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TIndex<T extends TSchema, K extends PropertyKey[]> = (
-  FromSchema<T, K>
+export type TIndex<Type extends TSchema, Key extends TSchema | PropertyKey[],
+  TypeKey extends TSchema = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key,
+  PropertyKeys extends PropertyKey[] = Key extends TSchema ? TIndexPropertyKeys<Key> : Key,
+  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, TypeKey]> :
+  [IsTypeRef, IsKeyRef] extends [false, true] ? TComputed<'Index', [Type, TypeKey]> :
+  [IsTypeRef, IsKeyRef] extends [true, false] ? TComputed<'Index', [Type, TypeKey]> : 
+  TFromType<Type, PropertyKeys>
 )
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>
+export 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 function Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>
+export 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 function Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>
+export 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 function Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>
+export function Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index(T: TSchema, K: any, options?: SchemaOptions): any {
-  // 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 as string[])
-  , options) as never
+// prettier-ignore
+export function Index(type: any, key: any, options?: SchemaOptions): any {
+  const typeKey: TSchema = IsArrayValue(key) ? UnionFromPropertyKeys(key as PropertyKey[]) : key 
+  const propertyKeys: PropertyKey[] = IsSchema(key) ? IndexPropertyKeys(key) : key
+  const isTypeRef: boolean = IsRef(type)
+  const isKeyRef: boolean = 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) 
+  ) as never
 }
diff --git a/src/type/intersect/intersect-evaluated.ts b/src/type/intersect/intersect-evaluated.ts
index a0c73484b..637009345 100644
--- a/src/type/intersect/intersect-evaluated.ts
+++ b/src/type/intersect/intersect-evaluated.ts
@@ -46,77 +46,77 @@ import { IsOptional, IsTransform } from '../guard/kind'
 // IsIntersectOptional
 // ------------------------------------------------------------------
 // prettier-ignore
-type TIsIntersectOptional<T extends TSchema[]> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]] 
-    ? L extends TOptional<TSchema> 
-      ? TIsIntersectOptional<R> 
+type TIsIntersectOptional<Types extends TSchema[]> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] 
+    ? Left extends TOptional<TSchema> 
+      ? TIsIntersectOptional<Right> 
       : false 
     : true
 )
 // prettier-ignore
-function IsIntersectOptional<T extends TSchema[]>(T: T): TIsIntersectOptional<T> {
-  return T.every(L => IsOptional(L)) as never
+function IsIntersectOptional<Types extends TSchema[]>(types: [...Types]): TIsIntersectOptional<Types> {
+  return types.every(left => IsOptional(left)) as never
 }
 // ------------------------------------------------------------------
 // RemoveOptionalFromType
 // ------------------------------------------------------------------
 // prettier-ignore
-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 TRemoveOptionalFromType<Type extends TSchema> = (
+  Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType<Type>> :
+  Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType<Type> :
+  Type
 )
 // prettier-ignore
-function RemoveOptionalFromType<T extends TSchema>(T: T): TRemoveOptionalFromType<T> {
+function RemoveOptionalFromType<Type extends TSchema>(type: Type): TRemoveOptionalFromType<Type> {
   return (
-    Discard(T, [OptionalKind])
+    Discard(type, [OptionalKind])
     ) as never
 }
 // ------------------------------------------------------------------
 // RemoveOptionalFromRest
 // ------------------------------------------------------------------
 // prettier-ignore
-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 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
 )
 // prettier-ignore
-function RemoveOptionalFromRest<T extends TSchema[]>(T: T): TRemoveOptionalFromRest<T> {
-  return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L) as never
+function RemoveOptionalFromRest<Types extends TSchema[]>(types: [...Types]): TRemoveOptionalFromRest<Types> {
+  return types.map(left => IsOptional(left) ? RemoveOptionalFromType(left) : left) as never
 }
 // ------------------------------------------------------------------
 // ResolveIntersect
 // ------------------------------------------------------------------
 // prettier-ignore
-type TResolveIntersect<T extends TSchema[]> = (
-  TIsIntersectOptional<T> extends true 
-    ? TOptional<TIntersect<TRemoveOptionalFromRest<T>>> 
-    : TIntersect<TRemoveOptionalFromRest<T>>
+type TResolveIntersect<Types extends TSchema[]> = (
+  TIsIntersectOptional<Types> extends true 
+    ? TOptional<TIntersect<TRemoveOptionalFromRest<Types>>> 
+    : TIntersect<TRemoveOptionalFromRest<Types>>
 )
 // prettier-ignore
-function ResolveIntersect<T extends TSchema[]>(T: [...T], options: SchemaOptions): TResolveIntersect<T> {
+function ResolveIntersect<Types extends TSchema[]>(types: [...Types], options: SchemaOptions): TResolveIntersect<Types> {
   return (
-    IsIntersectOptional(T)
-      ? Optional(IntersectCreate(RemoveOptionalFromRest(T) as TSchema[], options))
-      : IntersectCreate(RemoveOptionalFromRest(T) as TSchema[], options)
+    IsIntersectOptional(types)
+      ? Optional(IntersectCreate(RemoveOptionalFromRest(types) as TSchema[], options))
+      : IntersectCreate(RemoveOptionalFromRest(types) as TSchema[], options)
   ) as never
 }
 // ------------------------------------------------------------------
 // IntersectEvaluated
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TIntersectEvaluated<T extends TSchema[]> = (
-  T extends [] ? TNever :
-  T extends [TSchema] ? T[0] :
-  TResolveIntersect<T>
+export type TIntersectEvaluated<Types extends TSchema[]> = (
+  Types extends [TSchema] ? Types[0] :
+  Types extends [] ? TNever :
+  TResolveIntersect<Types>
 )
 /** `[Json]` Creates an evaluated Intersect type */
-export function IntersectEvaluated<T extends TSchema[], R = TIntersectEvaluated<T>>(T: [...T], options: IntersectOptions = {}): R {
-  if (T.length === 0) return Never(options) as never
-  if (T.length === 1) return CreateType(T[0], options) as never
-  if (T.some((schema) => IsTransform(schema))) throw new Error('Cannot intersect transform types')
-  return ResolveIntersect(T, options) as never
+export function IntersectEvaluated<Types extends TSchema[], Result extends TSchema = TIntersectEvaluated<Types>>(types: [...Types], options: IntersectOptions = {}): Result {
+  if (types.length === 1) return CreateType(types[0], options) as never
+  if (types.length === 0) return Never(options) as never
+  if (types.some((schema) => IsTransform(schema))) throw new Error('Cannot intersect transform types')
+  return ResolveIntersect(types, options) as never
 }
diff --git a/src/type/intersect/intersect.ts b/src/type/intersect/intersect.ts
index 66275057f..999d3d2af 100644
--- a/src/type/intersect/intersect.ts
+++ b/src/type/intersect/intersect.ts
@@ -40,15 +40,15 @@ import { IsTransform } from '../guard/kind'
 // Intersect
 // ------------------------------------------------------------------
 // prettier-ignore
-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 function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T> {
-  if (T.length === 0) return Never(options) as never
-  if (T.length === 1) return CreateType(T[0], options) as never
-  if (T.some((schema) => IsTransform(schema))) throw new Error('Cannot intersect transform types')
-  return IntersectCreate(T, options) as never
+export function Intersect<Types extends TSchema[]>(types: [...Types], options?: IntersectOptions): Intersect<Types> {
+  if (types.length === 1) return CreateType(types[0], options) as never
+  if (types.length === 0) return Never(options) as never
+  if (types.some((schema) => IsTransform(schema))) throw new Error('Cannot intersect transform types')
+  return IntersectCreate(types, options) as never
 }
diff --git a/src/type/module/compute.ts b/src/type/module/compute.ts
index ed4f42991..8fdd7b868 100644
--- a/src/type/module/compute.ts
+++ b/src/type/module/compute.ts
@@ -35,6 +35,7 @@ import { Awaited, type TAwaited } from '../awaited/index'
 import { AsyncIterator, type TAsyncIterator } from '../async-iterator/index'
 import { TComputed } from '../computed/index'
 import { Constructor, type TConstructor } from '../constructor/index'
+import { Index, type TIndex } from '../indexed/index'
 import { Function, type TFunction } from '../function/index'
 import { Intersect, type TIntersect, type TIntersectEvaluated } from '../intersect/index'
 import { Iterator, type TIterator } from '../iterator/index'
@@ -109,6 +110,17 @@ function FromAwaited<Parameters extends TSchema[]>(parameters: Parameters): TFro
   return Awaited(parameters[0]) as never
 }
 // ------------------------------------------------------------------
+// Index
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromIndex<Parameters extends TSchema[]> = (
+  Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TIndex<T0, T1> : never
+)
+// prettier-ignore
+function FromIndex<Parameters extends TSchema[]>(parameters: Parameters): TFromIndex<Parameters> {
+  return Index(parameters[0], parameters[1]) as never
+}
+// ------------------------------------------------------------------
 // KeyOf
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -171,6 +183,7 @@ type TFromComputed<ModuleProperties extends TProperties, Target extends string,
   Dereferenced extends TSchema[] = TDerefParameters<ModuleProperties, Parameters>
 > = (
   Target extends 'Awaited' ? TFromAwaited<Dereferenced> :
+  Target extends 'Index' ? TFromIndex<Dereferenced> :
   Target extends 'KeyOf' ? TFromKeyOf<Dereferenced> :
   Target extends 'Partial' ? TFromPartial<Dereferenced> :
   Target extends 'Omit' ? TFromOmit<Dereferenced> :
@@ -183,6 +196,7 @@ function FromComputed<ModuleProperties extends TProperties, Target extends strin
   const dereferenced = DerefParameters(moduleProperties, parameters)
   return (
     target === 'Awaited' ? FromAwaited(dereferenced) :
+    target === 'Index' ? FromIndex(dereferenced) :
     target === 'KeyOf' ? FromKeyOf(dereferenced) :
     target === 'Partial' ? FromPartial(dereferenced) :
     target === 'Omit' ? FromOmit(dereferenced) :
@@ -201,7 +215,7 @@ type TFromObject<ModuleProperties extends TProperties, Properties extends TPrope
 function FromObject<ModuleProperties extends TProperties, Properties extends TProperties>(moduleProperties: ModuleProperties, properties: Properties): TFromObject<ModuleProperties, Properties> {
   return Object(
     globalThis.Object.keys(properties).reduce((result, key) => {
-      return { ...result, [key]: FromType(moduleProperties, properties[key]) as TSchema }
+      return { ...result, [key]: FromType(moduleProperties, properties[key]) as never }
     }, {} as TProperties),
   ) as never
 }
@@ -218,7 +232,7 @@ function FromConstructor<ModuleProperties extends TProperties, Parameters extend
   parameters: [...Parameters],
   instanceType: InstanceType,
 ): TFromConstructor<ModuleProperties, Parameters, InstanceType> {
-  return Constructor(FromRest(moduleProperties, parameters as never), FromType(moduleProperties, instanceType)) as never
+  return Constructor(FromRest(moduleProperties, parameters as never), FromType(moduleProperties, instanceType) as never) as never
 }
 // ------------------------------------------------------------------
 // Function
@@ -233,7 +247,7 @@ function FromFunction<ModuleProperties extends TProperties, Parameters extends T
   parameters: [...Parameters],
   returnType: ReturnType,
 ): TFromFunction<ModuleProperties, Parameters, ReturnType> {
-  return Function(FromRest(moduleProperties, parameters as never), FromType(moduleProperties, returnType)) as never
+  return Function(FromRest(moduleProperties, parameters as never), FromType(moduleProperties, returnType) as never) as never
 }
 // ------------------------------------------------------------------
 // Tuple
@@ -327,7 +341,10 @@ export type TFromType<ModuleProperties extends TProperties, Type extends TSchema
 // prettier-ignore
 export function FromType<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromType<ModuleProperties, Type> {
   return (
-    KindGuard.IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters)) :
+    // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
+    // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
+    // be a priority as there is a potential for the current inference to break on TS compiler changes.
+    KindGuard.IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters) as never) :
     KindGuard.IsObject(type) ? CreateType(FromObject(moduleProperties, type.properties), type) :
     KindGuard.IsConstructor(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
     KindGuard.IsFunction(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) :
diff --git a/src/type/not/not.ts b/src/type/not/not.ts
index 256a3c8eb..eb283dfdf 100644
--- a/src/type/not/not.ts
+++ b/src/type/not/not.ts
@@ -37,6 +37,6 @@ export interface TNot<T extends TSchema = TSchema> extends TSchema {
   not: T
 }
 /** `[Json]` Creates a Not type */
-export function Not<T extends TSchema>(not: T, options?: SchemaOptions): TNot<T> {
-  return CreateType({ [Kind]: 'Not', not }, options) as never
+export function Not<Type extends TSchema>(type: Type, options?: SchemaOptions): TNot<Type> {
+  return CreateType({ [Kind]: 'Not', not: type }, options) as never
 }
diff --git a/src/type/required/required.ts b/src/type/required/required.ts
index de51d42bb..7ae6a234d 100644
--- a/src/type/required/required.ts
+++ b/src/type/required/required.ts
@@ -141,7 +141,7 @@ export type TRequired<Type extends TSchema> = (
   TObject<{}>
 )
 /** `[Json]` Constructs a type where all properties are required */
-export function Required<MappedResult extends TMappedResult>(mappedResult: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>
+export function Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>
 /** `[Json]` Constructs a type where all properties are required */
 export function Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>
 /** `[Json]` Constructs a type where all properties are required */
diff --git a/src/type/tuple/tuple.ts b/src/type/tuple/tuple.ts
index 67d564f9d..80b092c79 100644
--- a/src/type/tuple/tuple.ts
+++ b/src/type/tuple/tuple.ts
@@ -52,11 +52,11 @@ export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
   maxItems: number
 }
 /** `[Json]` Creates a Tuple type */
-export function Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T> {
+export function Tuple<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): TTuple<Types> {
   // prettier-ignore
   return CreateType(
-    items.length > 0 ?
-      { [Kind]: 'Tuple', type: 'array', items, additionalItems: false, minItems: items.length, maxItems: items.length } :
-      { [Kind]: 'Tuple', type: 'array', minItems: items.length, maxItems: items.length },
+    types.length > 0 ?
+      { [Kind]: 'Tuple', type: 'array', items: types, additionalItems: false, minItems: types.length, maxItems: types.length } :
+      { [Kind]: 'Tuple', type: 'array', minItems: types.length, maxItems: types.length },
   options) as never
 }
diff --git a/src/type/type/javascript.ts b/src/type/type/javascript.ts
index fad81ea22..101231eb2 100644
--- a/src/type/type/javascript.ts
+++ b/src/type/type/javascript.ts
@@ -49,11 +49,11 @@ import { Void, type TVoid } from '../void/index'
 /** JavaScript Type Builder with Static Resolution for TypeScript */
 export class JavaScriptTypeBuilder extends JsonTypeBuilder {
   /** `[JavaScript]` Creates a AsyncIterator type */
-  public AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T> {
+  public AsyncIterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TAsyncIterator<Type> {
     return AsyncIterator(items, options)
   }
   /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-  public Awaited<T extends TSchema>(schema: T, options?: SchemaOptions): TAwaited<T> {
+  public Awaited<Type extends TSchema>(schema: Type, options?: SchemaOptions): TAwaited<Type> {
     return Awaited(schema, options)
   }
   /** `[JavaScript]` Creates a BigInt type */
@@ -61,35 +61,35 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return BigInt(options)
   }
   /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-  public ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T> {
+  public ConstructorParameters<Type extends TConstructor>(schema: Type, options?: SchemaOptions): TConstructorParameters<Type> {
     return ConstructorParameters(schema, options)
   }
   /** `[JavaScript]` Creates a Constructor type */
-  public Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U> {
-    return Constructor(parameters, returns, options)
+  public Constructor<Parameters extends TSchema[], InstanceType extends TSchema>(parameters: [...Parameters], instanceType: InstanceType, options?: SchemaOptions): TConstructor<Parameters, InstanceType> {
+    return Constructor(parameters, instanceType, options)
   }
   /** `[JavaScript]` Creates a Date type */
   public Date(options: DateOptions = {}): TDate {
     return Date(options)
   }
   /** `[JavaScript]` Creates a Function type */
-  public Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U> {
-    return FunctionType(parameters, returns, options)
+  public Function<Parameters extends TSchema[], ReturnType extends TSchema>(parameters: [...Parameters], returnType: ReturnType, options?: SchemaOptions): TFunction<Parameters, ReturnType> {
+    return FunctionType(parameters, returnType, options)
   }
   /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-  public InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T> {
+  public InstanceType<Type extends TConstructor>(schema: Type, options?: SchemaOptions): TInstanceType<Type> {
     return InstanceType(schema, options)
   }
   /** `[JavaScript]` Creates an Iterator type */
-  public Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T> {
+  public Iterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TIterator<Type> {
     return Iterator(items, options)
   }
   /** `[JavaScript]` Extracts the Parameters from the given Function type */
-  public Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T> {
+  public Parameters<Type extends TFunction>(schema: Type, options?: SchemaOptions): TParameters<Type> {
     return Parameters(schema, options)
   }
   /** `[JavaScript]` Creates a Promise type */
-  public Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T> {
+  public Promise<Type extends TSchema>(item: Type, options?: SchemaOptions): TPromise<Type> {
     return Promise(item, options)
   }
   /** `[JavaScript]` Creates a RegExp type */
@@ -101,8 +101,8 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return RegExp(unresolved as any, options)
   }
   /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-  public ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T> {
-    return ReturnType(schema, options)
+  public ReturnType<Type extends TFunction>(type: Type, options?: SchemaOptions): TReturnType<Type> {
+    return ReturnType(type, options)
   }
   /** `[JavaScript]` Creates a Symbol type */
   public Symbol(options?: SchemaOptions): TSymbol {
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index 6a4bde307..acc91ce1f 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -75,32 +75,32 @@ export class JsonTypeBuilder {
   // Modifiers
   // ------------------------------------------------------------------------
   /** `[Json]` Creates a Readonly and Optional property */
-  public ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T> {
-    return ReadonlyOptional(schema)
+  public ReadonlyOptional<Type extends TSchema>(type: Type): TReadonlyOptional<Type> {
+    return ReadonlyOptional(type)
   }
   /** `[Json]` Creates a Readonly property */
-  public Readonly<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TReadonlyFromMappedResult<T, F>
+  public Readonly<Type extends TMappedResult, Flag extends boolean>(type: Type, enable: Flag): TReadonlyFromMappedResult<Type, Flag>
   /** `[Json]` Creates a Readonly property */
-  public Readonly<T extends TSchema, F extends boolean>(schema: T, enable: F): TReadonlyWithFlag<T, F>
+  public Readonly<Type extends TSchema, Flag extends boolean>(type: Type, enable: Flag): TReadonlyWithFlag<Type, Flag>
   /** `[Json]` Creates a Optional property */
-  public Readonly<T extends TMappedResult>(schema: T): TReadonlyFromMappedResult<T, true>
+  public Readonly<Type extends TMappedResult>(type: Type): TReadonlyFromMappedResult<Type, true>
   /** `[Json]` Creates a Readonly property */
-  public Readonly<T extends TSchema>(schema: T): TReadonlyWithFlag<T, true>
+  public Readonly<Type extends TSchema>(type: Type): TReadonlyWithFlag<Type, true>
   /** `[Json]` Creates a Readonly property */
-  public Readonly(schema: TSchema, enable?: boolean): any {
-    return Readonly(schema, enable ?? true)
+  public Readonly(type: TSchema, enable?: boolean): any {
+    return Readonly(type, enable ?? true)
   }
   /** `[Json]` Creates a Optional property */
-  public Optional<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TOptionalFromMappedResult<T, F>
+  public Optional<Type extends TMappedResult, Flag extends boolean>(type: Type, enable: Flag): TOptionalFromMappedResult<Type, Flag>
   /** `[Json]` Creates a Optional property */
-  public Optional<T extends TSchema, F extends boolean>(schema: T, enable: F): TOptionalWithFlag<T, F>
+  public Optional<Type extends TSchema, Flag extends boolean>(type: Type, enable: Flag): TOptionalWithFlag<Type, Flag>
   /** `[Json]` Creates a Optional property */
-  public Optional<T extends TMappedResult>(schema: T): TOptionalFromMappedResult<T, true>
+  public Optional<Type extends TMappedResult>(type: Type): TOptionalFromMappedResult<Type, true>
   /** `[Json]` Creates a Optional property */
-  public Optional<T extends TSchema>(schema: T): TOptionalWithFlag<T, true>
+  public Optional<Type extends TSchema>(type: Type): TOptionalWithFlag<Type, true>
   /** `[Json]` Creates a Optional property */
-  public Optional(schema: TSchema, enable?: boolean): any {
-    return Optional(schema, enable ?? true)
+  public Optional(type: TSchema, enable?: boolean): any {
+    return Optional(type, enable ?? true)
   }
   // ------------------------------------------------------------------------
   // Types
@@ -110,8 +110,8 @@ export class JsonTypeBuilder {
     return Any(options)
   }
   /** `[Json]` Creates an Array type */
-  public Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T> {
-    return Array(schema, options)
+  public Array<Type extends TSchema>(items: Type, options?: ArrayOptions): TArray<Type> {
+    return Array(items, options)
   }
   /** `[Json]` Creates a Boolean type */
   public Boolean(options?: SchemaOptions): TBoolean {
@@ -164,36 +164,36 @@ export class JsonTypeBuilder {
     return Extract(type, union, options)
   }
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>
+  public Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, key: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>
+  public 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 */
-  public Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>
+  public 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 */
-  public Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>
+  public Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>
   /** `[Json]` Returns an Indexed property type for the given keys */
-  public Index(schema: TSchema, unresolved: any, options?: SchemaOptions): any {
-    return Index(schema, unresolved, options)
+  public Index(type: TSchema, key: any, options?: SchemaOptions): any {
+    return Index(type, key, options)
   }
   /** `[Json]` Creates an Integer type */
   public Integer(options?: IntegerOptions): TInteger {
     return Integer(options)
   }
   /** `[Json]` Creates an Intersect type */
-  public Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T> {
-    return Intersect(T, options)
+  public Intersect<Types extends TSchema[]>(types: [...Types], options?: IntersectOptions): Intersect<Types> {
+    return Intersect(types, options)
   }
   /** `[Json]` Creates a KeyOf type */
-  public KeyOf<Type extends TSchema>(schema: Type, options?: SchemaOptions): TKeyOf<Type> {
-    return KeyOf(schema, options) as never
+  public KeyOf<Type extends TSchema>(type: Type, options?: SchemaOptions): TKeyOf<Type> {
+    return KeyOf(type, options) as never
   }
   /** `[Json]` Creates a Literal type */
-  public Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T> {
-    return Literal(value, options)
+  public Literal<LiteralValue extends TLiteralValue>(literalValue: LiteralValue, options?: SchemaOptions): TLiteral<LiteralValue> {
+    return Literal(literalValue, options)
   }
   /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-  public Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TLowercase<T> {
-    return Lowercase(schema, options)
+  public Lowercase<Type extends TSchema>(type: Type, options?: SchemaOptions): TLowercase<Type> {
+    return Lowercase(type, options)
   }
   /** `[Json]` Creates a Mapped object type */
   public Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R
@@ -212,8 +212,8 @@ export class JsonTypeBuilder {
     return Never(options)
   }
   /** `[Json]` Creates a Not type */
-  public Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T> {
-    return Not(schema, options)
+  public Not<T extends TSchema>(type: T, options?: SchemaOptions): TNot<T> {
+    return Not(type, options)
   }
   /** `[Json]` Creates a Null type */
   public Null(options?: SchemaOptions): TNull {
@@ -236,7 +236,7 @@ export class JsonTypeBuilder {
     return Omit(schema, selector, options)
   }
   /** `[Json]` Constructs a type where all properties are optional */
-  public Partial<MappedResult extends TMappedResult>(mappedResult: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>
+  public Partial<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>
   /** `[Json]` Constructs a type where all properties are optional */
   public Partial<Type extends TSchema>(type: Type, options?: SchemaOptions): TPartial<Type>
   /** `[Json]` Constructs a type where all properties are optional */
@@ -252,8 +252,8 @@ export class JsonTypeBuilder {
     return Pick(type, key, options)
   }
   /** `[Json]` Creates a Record type */
-  public Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecordOrObject<K, T> {
-    return Record(key, schema, options)
+  public Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: ObjectOptions): TRecordOrObject<Key, Value> {
+    return Record(key, value, options)
   }
   /** `[Json]` Creates a Recursive type */
   public Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T> {
@@ -264,7 +264,7 @@ export class JsonTypeBuilder {
     return Ref($ref, options)
   }
   /** `[Json]` Constructs a type where all properties are required */
-  public Required<MappedResult extends TMappedResult>(mappedResult: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>
+  public Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>
   /** `[Json]` Constructs a type where all properties are required */
   public Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>
   /** `[Json]` Constructs a type where all properties are required */
@@ -272,36 +272,36 @@ export class JsonTypeBuilder {
     return Required(type, options)
   }
   /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-  public Rest<T extends TSchema>(schema: T): TRest<T> {
-    return Rest(schema)
+  public Rest<Type extends TSchema>(type: Type): TRest<Type> {
+    return Rest(type)
   }
   /** `[Json]` Creates a String type */
   public String(options?: StringOptions): TString {
     return String(options)
   }
   /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-  public TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>
+  public TemplateLiteral<Syntax extends string>(syntax: Syntax, options?: SchemaOptions): TTemplateLiteralSyntax<Syntax>
   /** `[Json]` Creates a TemplateLiteral type */
-  public TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>
+  public TemplateLiteral<Kinds extends TTemplateLiteralKind[]>(kinds: [...Kinds], options?: SchemaOptions): TTemplateLiteral<Kinds>
   /** `[Json]` Creates a TemplateLiteral type */
   public TemplateLiteral(unresolved: TTemplateLiteralKind[] | string, options?: SchemaOptions) {
     return TemplateLiteral(unresolved as any, options)
   }
   /** `[Json]` Creates a Transform type */
-  public Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I> {
-    return Transform(schema)
+  public Transform<Type extends TSchema>(type: Type): TransformDecodeBuilder<Type> {
+    return Transform(type)
   }
   /** `[Json]` Creates a Tuple type */
-  public Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T> {
-    return Tuple(items, options)
+  public Tuple<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): TTuple<Types> {
+    return Tuple(types, options)
   }
   /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-  public Uncapitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TUncapitalize<T> {
-    return Uncapitalize(schema, options)
+  public Uncapitalize<Type extends TSchema>(type: Type, options?: SchemaOptions): TUncapitalize<Type> {
+    return Uncapitalize(type, options)
   }
   /** `[Json]` Creates a Union type */
-  public Union<T extends TSchema[]>(schemas: [...T], options?: SchemaOptions): Union<T> {
-    return Union(schemas, options)
+  public Union<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): Union<Types> {
+    return Union(types, options)
   }
   /** `[Json]` Creates an Unknown type */
   public Unknown(options?: SchemaOptions): TUnknown {
diff --git a/src/type/union/union-evaluated.ts b/src/type/union/union-evaluated.ts
index 9e4004a20..8ba1eb21b 100644
--- a/src/type/union/union-evaluated.ts
+++ b/src/type/union/union-evaluated.ts
@@ -44,43 +44,43 @@ import { IsOptional } from '../guard/kind'
 // IsUnionOptional
 // ------------------------------------------------------------------
 // prettier-ignore
-type TIsUnionOptional<T extends TSchema[]> = (
-  T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? 
-    L extends TOptional<TSchema> 
+type TIsUnionOptional<Types extends TSchema[]> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? 
+    Left extends TOptional<TSchema> 
       ? true 
-      : TIsUnionOptional<R> 
+      : TIsUnionOptional<Right> 
     : false
 )
 // prettier-ignore
-function IsUnionOptional<T extends TSchema[]>(T: T): TIsUnionOptional<T> {
-  return T.some(L => IsOptional(L)) as never
+function IsUnionOptional<Types extends TSchema[]>(types: Types): TIsUnionOptional<Types> {
+  return types.some(type => IsOptional(type)) as never
 }
 // ------------------------------------------------------------------
 // RemoveOptionalFromRest
 // ------------------------------------------------------------------
 // prettier-ignore
-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 TRemoveOptionalFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (
+  Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]]
+    ? Left extends TOptional<infer S extends TSchema>
+      ? TRemoveOptionalFromRest<Right, [...Result, TRemoveOptionalFromType<S>]>
+      : TRemoveOptionalFromRest<Right, [...Result, Left]>
+    : Result
 )
 // prettier-ignore
-function RemoveOptionalFromRest<T extends TSchema[]>(T: T): TRemoveOptionalFromRest<T> {
-  return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L) as never
+function RemoveOptionalFromRest<Types extends TSchema[]>(types: Types): TRemoveOptionalFromRest<Types> {
+  return types.map(left => IsOptional(left) ? RemoveOptionalFromType(left) : left) as never
 }
 // ------------------------------------------------------------------
 // RemoveOptionalFromType
 // ------------------------------------------------------------------
 // prettier-ignore
-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 TRemoveOptionalFromType<Type extends TSchema> = (
+  Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType<Type>> :
+  Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType<Type> :
+  Type
 )
 // prettier-ignore
-function RemoveOptionalFromType<T extends TSchema>(T: T): TRemoveOptionalFromType<T> {
+function RemoveOptionalFromType<Type extends TSchema>(T: Type): TRemoveOptionalFromType<Type> {
   return (
     Discard(T, [OptionalKind])
   ) as never
@@ -89,34 +89,38 @@ function RemoveOptionalFromType<T extends TSchema>(T: T): TRemoveOptionalFromTyp
 // ResolveUnion
 // ------------------------------------------------------------------
 // prettier-ignore
-type TResolveUnion<T extends TSchema[], R extends TSchema[] = TRemoveOptionalFromRest<T>> = (
-  TIsUnionOptional<T> extends true 
-    ? TOptional<TUnion<R>> 
-    : TUnion<R>
+type TResolveUnion<Types extends TSchema[], 
+  Result extends TSchema[] = TRemoveOptionalFromRest<Types>,
+  IsOptional extends boolean = TIsUnionOptional<Types>
+> = (
+  IsOptional extends true 
+    ? TOptional<TUnion<Result>> 
+    : TUnion<Result>
 )
 // prettier-ignore
-function ResolveUnion<T extends TSchema[]>(T: T, options?: SchemaOptions): TResolveUnion<T> {
+function ResolveUnion<Types extends TSchema[]>(types: Types, options?: SchemaOptions): TResolveUnion<Types> {
+  const isOptional = IsUnionOptional(types)
   return (
-    IsUnionOptional(T)
-      ? Optional(UnionCreate(RemoveOptionalFromRest(T) as TSchema[], options))
-      : UnionCreate(RemoveOptionalFromRest(T) as TSchema[], options)
+    isOptional
+      ? Optional(UnionCreate(RemoveOptionalFromRest(types) as TSchema[], options))
+      : UnionCreate(RemoveOptionalFromRest(types) as TSchema[], options)
   ) as never
 }
 // ------------------------------------------------------------------
 // Union
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TUnionEvaluated<T extends TSchema[]> = (
-  T extends [] ? TNever :
-  T extends [TSchema] ? T[0] :
-  TResolveUnion<T>
+export type TUnionEvaluated<Types extends TSchema[]> = (
+  Types extends [TSchema] ? Types[0] :
+  Types extends [] ? TNever :
+  TResolveUnion<Types>
 )
 /** `[Json]` Creates an evaluated Union type */
-export function UnionEvaluated<T extends TSchema[], R = TUnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R {
+export function UnionEvaluated<Types extends TSchema[], Result = TUnionEvaluated<Types>>(T: [...Types], options?: SchemaOptions): Result {
   // prettier-ignore
   return (
-    T.length === 0 ? Never(options) :
     T.length === 1 ? CreateType(T[0], options) :
+    T.length === 0 ? Never(options) :
     ResolveUnion(T, options)
   ) as never
 }
diff --git a/src/type/union/union.ts b/src/type/union/union.ts
index a057141c8..bacffbd19 100644
--- a/src/type/union/union.ts
+++ b/src/type/union/union.ts
@@ -39,11 +39,11 @@ export type Union<T extends TSchema[]> = (
   TUnion<T>
 )
 /** `[Json]` Creates a Union type */
-export function Union<T extends TSchema[]>(T: [...T], options?: SchemaOptions): Union<T> {
+export function Union<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): Union<Types> {
   // prettier-ignore
   return (
-    T.length === 0 ? Never(options) :
-    T.length === 1 ? CreateType(T[0], options) :
-    UnionCreate(T, options)
-  ) as Union<T>
+    types.length === 0 ? Never(options) :
+    types.length === 1 ? CreateType(types[0], options) :
+    UnionCreate(types, options)
+  ) as Union<Types>
 }