diff --git a/example/index.ts b/example/index.ts
index 10a612d8..11348e92 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -14,50 +14,22 @@ import { Type, TypeGuard, Kind, Static, TSchema } from '@sinclair/typebox'
 //  - Required (Computed)
 //  - KeyOf
 
-//
-// Todo:
-//  - Have more problems dealing with options not mapping over correctly. This is a
-//    problem for deferred types as the XRef can't be naively assign options post
-//    creation. I could check for these cases however.
-//  - Support Recursive Deref. This will be challenging, but ideally we want to
-//    support Partial(Required(Partial(Type.Ref('A')))). This probably means
-//    ditching the current XRef for a Deferred node like thing.
-
-const M = Parse('string')
-
-const Module = Parse(`module {
-  type A = {
-    x: number
-    y: number
-    z: number
-  }
-
-  type T = Required<Pick<A, 'x'>> &
-           Partial<Omit<A, 'x'>>
-}`)
-
-// const Module = Type.Module({
-//   A: Type.Partial(Type.Object({
-//     x: Type.Number(),
-//     y: Type.Number(),
-//     z: Type.Number(),
-//   })),
-//   T: Type.Intersect([
-//     Type.Required(Type.Pick(Type.Ref('A'), ['x'])),
-//     Type.Partial(Type.Omit(Type.Ref('A'), ['x'])),
-//   ])
-// })
-
-const AA = Type.Required(Type.Pick(Type.Ref('A'), ['x']))
-
+const Module = Type.Module({
+  A: Type.Object({
+    x: Type.Number(),
+    y: Type.Number(),
+  }),
+  T: 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 T>
+type A = Static<typeof A>
+type T = Static<typeof T>
 
 // Ok(T, { nodes: [{ nodes: [{ nodes: [] }, { nodes: [] }] }] })
-
-const A = Type.Omit(Type.String(), Type.Ref('A'))
diff --git a/readme.md b/readme.md
index 3adeae92..c1669cfd 100644
--- a/readme.md
+++ b/readme.md
@@ -1074,22 +1074,25 @@ const T = Type.Object({                             // const T: TObject<{
 
 ### Module
 
-Syntax Types support Module parsing, which is useful for processing multiple TypeScript types. Module parsing supports type alias and interface definitions. Generics are currently unsupported as of 0.34.0.
+Syntax Types also support Module parsing. This can provide a more terse syntax for creating Module definitions, but comes with an inference performance cost. Module parsing supports interface and type alias definitions. Generics types are currently unsupported. Consider the following which defines a explicit Module on the left, and the parsed Module on the right.
 
 ```typescript
-const Foo = Parse(`module Foo {
-
-  export type A = string
-
-  export type B = number
-
-  export type C = A | B
-
-}`)
-
-const C = Foo.Import('C')                           // const C: TImport<{
-                                                    //   ...
-                                                    // }, 'C'>
+const Module = Type.Module({                        // const Module = Parse(`module {
+                                                    //   
+  User: Type.Object({                               //   export interface User {
+    id: Type.String(),                              //     id: string
+    name: Type.String(),                            //     name: string
+    email: Type.String(),                           //     email: string
+  }),                                               //   }
+                                                    //   
+  PartialUser: Type.Intersect([                     //   export type PartialUser = (
+    Type.Pick(Type.Ref('User'), ['id']),            //     Pick<User, 'id'> &
+    Type.Partial(                                   //     Partial<Omit<User, 'id'>>
+      Type.Omit(Type.Ref('User'), ['id'])           //   )
+    ),                                              //
+  ])                                                //
+                                                    //
+})                                                  // }`)
 ```
 
 <a name='syntax-context'></a>
diff --git a/src/type/keyof/index.ts b/src/type/keyof/index.ts
index f0c1a32c..67512251 100644
--- a/src/type/keyof/index.ts
+++ b/src/type/keyof/index.ts
@@ -29,5 +29,4 @@ THE SOFTWARE.
 export * from './keyof-from-mapped-result'
 export * from './keyof-property-entries'
 export * from './keyof-property-keys'
-export * from './keyof-ref'
 export * from './keyof'
diff --git a/src/type/keyof/keyof-from-mapped-result.ts b/src/type/keyof/keyof-from-mapped-result.ts
index f4b90bfa..0be65975 100644
--- a/src/type/keyof/keyof-from-mapped-result.ts
+++ b/src/type/keyof/keyof-from-mapped-result.ts
@@ -30,21 +30,17 @@ import type { SchemaOptions } from '../schema/index'
 import type { Ensure, Evaluate } from '../helpers/index'
 import type { TProperties } from '../object/index'
 import { MappedResult, type TMappedResult } from '../mapped/index'
-import { KeyOf, type TKeyOfUnion } from './keyof'
+import { KeyOf, type TKeyOfFromType } from './keyof'
 import { Clone } from '../clone/value'
 // ------------------------------------------------------------------
 // FromProperties
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromProperties<
-  Properties extends TProperties
-> = (
-  { [K2 in keyof Properties]: TKeyOfUnion<Properties[K2]> }   
+type TFromProperties<Properties extends TProperties> = (
+  { [K2 in keyof Properties]: TKeyOfFromType<Properties[K2]> }   
 )
 // prettier-ignore
-function FromProperties<
-  Properties extends TProperties
->(properties: Properties, options?: SchemaOptions): TFromProperties<Properties> {
+function FromProperties<Properties extends TProperties>(properties: Properties, options?: SchemaOptions): TFromProperties<Properties> {
   const result = {} as TProperties
   for(const K2 of globalThis.Object.getOwnPropertyNames(properties)) result[K2] = KeyOf(properties[K2], Clone(options))
   return result as never
@@ -53,15 +49,11 @@ function FromProperties<
 // FromMappedResult
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromMappedResult<
-  MappedResult extends TMappedResult
-> = (
+type TFromMappedResult<MappedResult extends TMappedResult> = (
   Evaluate<TFromProperties<MappedResult['properties']>>
 )
 // prettier-ignore
-function FromMappedResult<
-  MappedResult extends TMappedResult
->(mappedResult: MappedResult, options?: SchemaOptions): TFromMappedResult<MappedResult> {
+function FromMappedResult<MappedResult extends TMappedResult>(mappedResult: MappedResult, options?: SchemaOptions): TFromMappedResult<MappedResult> {
   return FromProperties(mappedResult.properties, options) as never
 }
 // ------------------------------------------------------------------
diff --git a/src/type/keyof/keyof-property-keys.ts b/src/type/keyof/keyof-property-keys.ts
index 28f945bb..25cfd2df 100644
--- a/src/type/keyof/keyof-property-keys.ts
+++ b/src/type/keyof/keyof-property-keys.ts
@@ -44,58 +44,56 @@ import { IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsRecord } from '../g
 // FromRest
 // ------------------------------------------------------------------
 // prettier-ignore
-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 TFromRest<Types extends TSchema[], Result extends PropertyKey[][] = []> = (
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromRest<R, [...Result, TKeyOfPropertyKeys<L>]>
+    : Result
 )
 // prettier-ignore
-function FromRest<T extends TSchema[]>(T: [...T]): TFromRest<T> {
-  const Acc = [] as PropertyKey[][]
-  for(const L of T) Acc.push(KeyOfPropertyKeys(L))
-  return Acc as never
+function FromRest<Types extends TSchema[]>(types: [...Types]): TFromRest<Types> {
+  const result = [] as PropertyKey[][]
+  for(const L of types) result.push(KeyOfPropertyKeys(L))
+  return result as never
 }
 // ------------------------------------------------------------------
 // FromIntersect
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromIntersect<
-  T extends TSchema[], 
-  C extends PropertyKey[][] = TFromRest<T>,
-  R extends PropertyKey[] = TSetUnionMany<C>
-> = R
+type TFromIntersect<Types extends TSchema[], 
+  PropertyKeysArray extends PropertyKey[][] = TFromRest<Types>,
+  PropertyKeys extends PropertyKey[] = TSetUnionMany<PropertyKeysArray>
+> = PropertyKeys
 // prettier-ignore
-function FromIntersect<T extends TSchema[]>(T: [...T]): TFromIntersect<T> {
-  const C = FromRest(T) as PropertyKey[][]
-  const R = SetUnionMany(C)
-  return R as never
+function FromIntersect<Types extends TSchema[]>(types: [...Types]): TFromIntersect<Types> {
+  const propertyKeysArray = FromRest(types) as PropertyKey[][]
+  const propertyKeys = SetUnionMany(propertyKeysArray)
+  return propertyKeys as never
 }
 // ------------------------------------------------------------------
 // FromUnion
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromUnion<
-  T extends TSchema[], 
-  C extends PropertyKey[][] = TFromRest<T>,
-  R extends PropertyKey[] = TSetIntersectMany<C>
-> = R
+type TFromUnion<Types extends TSchema[], 
+  PropertyKeysArray extends PropertyKey[][] = TFromRest<Types>,
+  PropertyKeys extends PropertyKey[] = TSetIntersectMany<PropertyKeysArray>
+> = PropertyKeys
 // prettier-ignore
-function FromUnion<T extends TSchema[]>(T: [...T]): TFromUnion<T> {
-  const C = FromRest(T) as PropertyKey[][]
-  const R = SetIntersectMany(C)
-  return R as never
+function FromUnion<Types extends TSchema[]>(types: [...Types]): TFromUnion<Types> {
+  const propertyKeysArray = FromRest(types) as PropertyKey[][]
+  const propertyKeys = SetIntersectMany(propertyKeysArray)
+  return propertyKeys as never
 }
 // ------------------------------------------------------------------
 // FromTuple
 // ------------------------------------------------------------------
 // prettier-ignore
-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]>
+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
 // prettier-ignore
-function FromTuple<T extends TSchema[]>(T: [...T]): TFromTuple<T> {
-  return T.map((_, I) => I.toString()) as never
+function FromTuple<Types extends TSchema[]>(types: [...Types]): TFromTuple<Types> {
+  return types.map((_, indexer) => indexer.toString()) as never
 }
 // ------------------------------------------------------------------
 // FromArray
@@ -114,11 +112,11 @@ function FromArray<_ extends TSchema>(_: _): TFromArray<_> {
 // FromProperties
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromProperties<T extends TProperties> = (
-  UnionToTuple<keyof T>
+type TFromProperties<Properties extends TProperties> = (
+  UnionToTuple<keyof Properties>
 )
 // prettier-ignore
-function FromProperties<T extends TProperties>(T: T): TFromProperties<T> {
+function FromProperties<Properties extends TProperties>(T: Properties): TFromProperties<Properties> {
   return (
     globalThis.Object.getOwnPropertyNames(T)
   ) as never
@@ -140,25 +138,25 @@ function FromPatternProperties(patternProperties: Record<PropertyKey, TSchema>):
 // KeyOfPropertyKeys
 // ------------------------------------------------------------------
 // prettier-ignore
-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> :
+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. */
 // prettier-ignore
-export function KeyOfPropertyKeys<T extends TSchema>(T: T): TKeyOfPropertyKeys<T> {
+export function KeyOfPropertyKeys<Type extends TSchema>(type: Type): TKeyOfPropertyKeys<Type> {
   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) :
+    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) :
     []
   ) as never
 }
diff --git a/src/type/keyof/keyof-ref.ts b/src/type/keyof/keyof-ref.ts
deleted file mode 100644
index 47acfcee..00000000
--- a/src/type/keyof/keyof-ref.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2024 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-
-import { Kind } from '../symbols/symbols'
-import { TSchema, SchemaOptions } from '../schema/schema'
-import { CreateType } from '../create/index'
-
-export interface TKeyOfRef<Ref extends string = string> extends TSchema {
-  [Kind]: 'KeyOfRef'
-  static: unknown
-  $ref: Ref
-}
-/** Creates a KeyOfRef Ref */
-export function KeyOfRef<Ref extends string>($ref: Ref, options?: SchemaOptions): TKeyOfRef<Ref> {
-  return CreateType({ [Kind]: 'KeyOfRef', $ref }, options) as never
-}
diff --git a/src/type/keyof/keyof.ts b/src/type/keyof/keyof.ts
index 587e1e07..fbd20df6 100644
--- a/src/type/keyof/keyof.ts
+++ b/src/type/keyof/keyof.ts
@@ -33,16 +33,55 @@ import type { TMappedResult } from '../mapped/index'
 import type { SchemaOptions } from '../schema/index'
 import { Literal, type TLiteral, type TLiteralValue } from '../literal/index'
 import { Number, type TNumber } from '../number/index'
+import { Computed, TComputed } from '../computed/index'
 import { Ref, type TRef } from '../ref/index'
 import { KeyOfPropertyKeys, type TKeyOfPropertyKeys } from './keyof-property-keys'
 import { UnionEvaluated, type TUnionEvaluated } from '../union/index'
 import { KeyOfFromMappedResult, type TKeyOfFromMappedResult } from './keyof-from-mapped-result'
-import { KeyOfRef, TKeyOfRef } from './keyof-ref'
 
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsRef } from '../guard/kind'
+import { IsMappedResult, IsRef, IsComputed } from '../guard/kind'
+// ------------------------------------------------------------------
+// FromComputed
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<
+  TComputed<'KeyOf', [TComputed<Target, Parameters>]>
+>
+// prettier-ignore
+function FromComputed<Target extends string, Parameters extends TSchema[]>(target: Target, parameters: Parameters): TFromComputed<Target, Parameters> {
+  return Computed('KeyOf', [Computed(target, parameters)]) as never
+}
+// ------------------------------------------------------------------
+// FromRef
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRef<Ref extends string> = Ensure<
+  TComputed<'KeyOf', [TRef<Ref>]>
+>
+// prettier-ignore
+function FromRef<Ref extends string>($ref: Ref): TFromRef<Ref> {
+  return Computed('KeyOf', [Ref($ref)]) as never
+}
+// ------------------------------------------------------------------
+// KeyOfFromType
+// ------------------------------------------------------------------
+// prettier-ignore
+/** `[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>
+// prettier-ignore
+function KeyOfFromType<Type extends TSchema>(type: Type, options?: SchemaOptions): TKeyOfFromType<Type> {
+  const propertyKeys = KeyOfPropertyKeys(type) as PropertyKey[]
+  const propertyKeyTypes = KeyOfPropertyKeysToRest(propertyKeys)
+  const result = UnionEvaluated(propertyKeyTypes)
+  return CreateType(result, options) as never
+}
 // ------------------------------------------------------------------
 // FromPropertyKeys
 // ------------------------------------------------------------------
@@ -58,37 +97,17 @@ export type TKeyOfPropertyKeysToRest<PropertyKeys extends PropertyKey[], Result
 export function KeyOfPropertyKeysToRest<PropertyKeys extends PropertyKey[]>(propertyKeys: [...PropertyKeys]): TKeyOfPropertyKeysToRest<PropertyKeys> {
   return propertyKeys.map(L => L === '[number]' ? Number() : Literal(L as TLiteralValue)) as never
 }
-// ------------------------------------------------------------------
-// TKeyOfUnion
-// ------------------------------------------------------------------
-// prettier-ignore
-export type TKeyOfUnion<
-  Type extends TSchema, 
-  PropertyKeys extends PropertyKey[] = TKeyOfPropertyKeys<Type>,
-  PropertyKeyTypes extends TSchema[] = TKeyOfPropertyKeysToRest<PropertyKeys>,
-  Result = TUnionEvaluated<PropertyKeyTypes>
-> = Ensure<Result>
-
 // ------------------------------------------------------------------
 // TKeyOf
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TKeyOf<Type extends TSchema> = (
-  Type extends TRef<infer S extends string> ? TKeyOfRef<S> :
+  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> :
-  TKeyOfUnion<Type>
+  TKeyOfFromType<Type>
 )
 /** `[Json]` Creates a KeyOf type */
 export function KeyOf<Type extends TSchema>(type: Type, options?: SchemaOptions): TKeyOf<Type> {
-  // Note: This type has become overwhelmed with various overloads. Refactor in next revision.
-  if (IsRef(type)) {
-    return KeyOfRef(type.$ref, options) as never
-  } else if (IsMappedResult(type)) {
-    return KeyOfFromMappedResult(type, options) as never
-  } else {
-    const K = KeyOfPropertyKeys(type) as PropertyKey[]
-    const S = KeyOfPropertyKeysToRest(K)
-    const U = UnionEvaluated(S)
-    return CreateType(U, options) as never
-  }
+  return (IsComputed(type) ? FromComputed(type.target, type.parameters) : IsRef(type) ? FromRef(type.$ref) : IsMappedResult(type) ? KeyOfFromMappedResult(type, options) : KeyOfFromType(type, options)) as never
 }
diff --git a/src/type/module/compute.ts b/src/type/module/compute.ts
index 65204035..ed4f4299 100644
--- a/src/type/module/compute.ts
+++ b/src/type/module/compute.ts
@@ -38,7 +38,7 @@ import { Constructor, type TConstructor } from '../constructor/index'
 import { Function, type TFunction } from '../function/index'
 import { Intersect, type TIntersect, type TIntersectEvaluated } from '../intersect/index'
 import { Iterator, type TIterator } from '../iterator/index'
-import { KeyOf, type TKeyOf, type TKeyOfRef } from '../keyof/index'
+import { KeyOf, type TKeyOf } from '../keyof/index'
 import { Object, type TObject, type TProperties } from '../object/index'
 import { Omit, type TOmit } from '../omit/index'
 import { Pick, type TPick } from '../pick/index'
@@ -102,18 +102,29 @@ function Deref<ModuleProperties extends TProperties, Ref extends string>(moduleP
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromAwaited<Parameters extends TSchema[]> = (
-  Parameters extends [infer T0 extends TSchema] ? TAwaited<T0> : TNever
+  Parameters extends [infer T0 extends TSchema] ? TAwaited<T0> : never
 )
 // prettier-ignore
 function FromAwaited<Parameters extends TSchema[]>(parameters: Parameters): TFromAwaited<Parameters> {
   return Awaited(parameters[0]) as never
 }
 // ------------------------------------------------------------------
+// KeyOf
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromKeyOf<Parameters extends TSchema[]> = (
+  Parameters extends [infer T0 extends TSchema] ? TKeyOf<T0> : never
+)
+// prettier-ignore
+function FromKeyOf<Parameters extends TSchema[]>(parameters: Parameters): TFromAwaited<Parameters> {
+  return KeyOf(parameters[0]) as never
+}
+// ------------------------------------------------------------------
 // Partial
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromPartial<Parameters extends TSchema[]> = (
-  Parameters extends [infer T0 extends TSchema] ? TPartial<T0> : TNever
+  Parameters extends [infer T0 extends TSchema] ? TPartial<T0> : never
 )
 // prettier-ignore
 function FromPartial<Parameters extends TSchema[]>(parameters: Parameters): TFromPartial<Parameters> {
@@ -124,7 +135,7 @@ function FromPartial<Parameters extends TSchema[]>(parameters: Parameters): TFro
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromOmit<Parameters extends TSchema[]> = (
-  Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TOmit<T0, T1> : TNever
+  Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TOmit<T0, T1> : never
 )
 // prettier-ignore
 function FromOmit<Parameters extends TSchema[]>(parameters: Parameters): TFromPick<Parameters> {
@@ -135,7 +146,7 @@ function FromOmit<Parameters extends TSchema[]>(parameters: Parameters): TFromPi
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromPick<Parameters extends TSchema[]> = (
-  Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TPick<T0, T1> : TNever
+  Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TPick<T0, T1> : never
 )
 // prettier-ignore
 function FromPick<Parameters extends TSchema[]>(parameters: Parameters): TFromPick<Parameters> {
@@ -146,7 +157,7 @@ function FromPick<Parameters extends TSchema[]>(parameters: Parameters): TFromPi
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromRequired<Parameters extends TSchema[]> = (
-  Parameters extends [infer T0 extends TSchema] ? TRequired<T0> : TNever
+  Parameters extends [infer T0 extends TSchema] ? TRequired<T0> : never
 )
 // prettier-ignore
 function FromRequired<Parameters extends TSchema[]>(parameters: Parameters): TFromPick<Parameters> {
@@ -160,6 +171,7 @@ type TFromComputed<ModuleProperties extends TProperties, Target extends string,
   Dereferenced extends TSchema[] = TDerefParameters<ModuleProperties, Parameters>
 > = (
   Target extends 'Awaited' ? TFromAwaited<Dereferenced> :
+  Target extends 'KeyOf' ? TFromKeyOf<Dereferenced> :
   Target extends 'Partial' ? TFromPartial<Dereferenced> :
   Target extends 'Omit' ? TFromOmit<Dereferenced> :
   Target extends 'Pick' ? TFromPick<Dereferenced> :
@@ -171,6 +183,7 @@ function FromComputed<ModuleProperties extends TProperties, Target extends strin
   const dereferenced = DerefParameters(moduleProperties, parameters)
   return (
     target === 'Awaited' ? FromAwaited(dereferenced) :
+    target === 'KeyOf' ? FromKeyOf(dereferenced) :
     target === 'Partial' ? FromPartial(dereferenced) :
     target === 'Omit' ? FromOmit(dereferenced) :
     target === 'Pick' ? FromPick(dereferenced) :
diff --git a/src/type/required/required.ts b/src/type/required/required.ts
index 35d2408d..de51d42b 100644
--- a/src/type/required/required.ts
+++ b/src/type/required/required.ts
@@ -131,13 +131,13 @@ function RequiredResolve<Type extends TSchema>(type: Type): TRequired<Type> {
 // TRequired
 // ------------------------------------------------------------------
 // prettier-ignore
-export type TRequired<T extends TSchema> = (
-  T extends TRecursive<infer Type extends TSchema> ? TRecursive<TRequired<Type>> :
-  T extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> :
-  T extends TRef<infer Ref extends string> ? TFromRef<Ref> :
-  T extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> :
-  T extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> :
-  T extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> :
+export type TRequired<Type extends TSchema> = (
+  Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TRequired<Type>> :
+  Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> :
+  Type extends TRef<infer Ref extends string> ? TFromRef<Ref> :
+  Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> :
+  Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> :
+  Type extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> :
   TObject<{}>
 )
 /** `[Json]` Constructs a type where all properties are required */