diff --git a/example/index.ts b/example/index.ts
index c871883a..10a612d8 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -11,7 +11,7 @@ import { Type, TypeGuard, Kind, Static, TSchema } from '@sinclair/typebox'
 //  - Partial (Computed)
 //  - Pick (Computed)
 //  - Omit (Computed)
-//  - Required
+//  - Required (Computed)
 //  - KeyOf
 
 //
@@ -25,27 +25,30 @@ import { Type, TypeGuard, Kind, Static, TSchema } from '@sinclair/typebox'
 
 const M = Parse('string')
 
-// const Module = Parse(`module {
-//   type A = {
-//     x: number
-//     y: number
-//     z: number
-//   }
-
-//   type K = 'z' | 'y'
-
-//   type T = Partial<Pick<A, K>>
-// }`)
-
-const Module = Type.Module({
-  A: Type.Object({
-    x: Type.Number(),
-    y: Type.Number(),
-    z: Type.Number(),
-  }),
-  K: Type.Union([Type.Literal('z'), Type.Literal('y')]),
-  T: Type.Partial(Type.Omit(Type.Ref('A'), Type.Ref('K'))),
-})
+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 T = Module.Import('T')
 
@@ -57,4 +60,4 @@ type A = Static<typeof T>
 
 // Ok(T, { nodes: [{ nodes: [{ nodes: [] }, { nodes: [] }] }] })
 
-const A = Type.Omit(Type.String(), Type.Ref('A'))
\ No newline at end of file
+const A = Type.Omit(Type.String(), Type.Ref('A'))
diff --git a/src/syntax/static.ts b/src/syntax/static.ts
index c8407ae5..ddd48ea7 100644
--- a/src/syntax/static.ts
+++ b/src/syntax/static.ts
@@ -776,7 +776,7 @@ type Partial = Static.Tuple<[
 // prettier-ignore
 interface RequiredMapping extends Static.IMapping {
   output: this['input'] extends ['Required', LAngle, infer Type extends Types.TSchema, RAngle]
-    ? Types.TPartial<Type>
+    ? Types.TRequired<Type>
     : never
 }
 // prettier-ignore
diff --git a/src/type/module/compute.ts b/src/type/module/compute.ts
index dc48f382..65204035 100644
--- a/src/type/module/compute.ts
+++ b/src/type/module/compute.ts
@@ -45,7 +45,7 @@ import { Pick, type TPick } from '../pick/index'
 import { Never, type TNever } from '../never/index'
 import { Partial, TPartial } from '../partial/index'
 import { Ref, type TRef } from '../ref/index'
-import { Required, TRequired, TRequiredRef } from '../required/index'
+import { Required, TRequired } from '../required/index'
 import { Tuple, type TTuple } from '../tuple/index'
 import { Union, type TUnion, type TUnionEvaluated } from '../union/index'
 
@@ -54,13 +54,14 @@ import { Union, type TUnion, type TUnionEvaluated } from '../union/index'
 // ------------------------------------------------------------------
 import * as KindGuard from '../guard/kind'
 
-
 // ------------------------------------------------------------------
-// Deref
+// DerefParameters
+//
+// Dereferences TComputed parameters. It is important to note that
+// dereferencing anything other than these parameters may result
+// inference and evaluation problems, potentially resulting in a
+// stack overflow. All open TRef types must be preserved !!!
 //
-// Derferences a type. This type must only be used in the context
-// of dereferencing TComputed parameters. Attempting to deref
-// outside parameters will result in stack overflow.
 // ------------------------------------------------------------------
 // prettier-ignore
 type TDerefParameters<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (
@@ -141,7 +142,18 @@ function FromPick<Parameters extends TSchema[]>(parameters: Parameters): TFromPi
   return Pick(parameters[0], parameters[1]) as never
 }
 // ------------------------------------------------------------------
-// ComputeComputed
+// Required
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRequired<Parameters extends TSchema[]> = (
+  Parameters extends [infer T0 extends TSchema] ? TRequired<T0> : TNever
+)
+// prettier-ignore
+function FromRequired<Parameters extends TSchema[]>(parameters: Parameters): TFromPick<Parameters> {
+  return Required(parameters[0]) as never
+}
+// ------------------------------------------------------------------
+// Computed
 // ------------------------------------------------------------------
 // prettier-ignore
 type TFromComputed<ModuleProperties extends TProperties, Target extends string, Parameters extends TSchema[],
@@ -151,6 +163,7 @@ type TFromComputed<ModuleProperties extends TProperties, Target extends string,
   Target extends 'Partial' ? TFromPartial<Dereferenced> :
   Target extends 'Omit' ? TFromOmit<Dereferenced> :
   Target extends 'Pick' ? TFromPick<Dereferenced> :
+  Target extends 'Required' ? TFromRequired<Dereferenced> :
   TNever
 )
 // prettier-ignore
@@ -161,6 +174,7 @@ function FromComputed<ModuleProperties extends TProperties, Target extends strin
     target === 'Partial' ? FromPartial(dereferenced) :
     target === 'Omit' ? FromOmit(dereferenced) :
     target === 'Pick' ? FromPick(dereferenced) :
+    target === 'Required' ? FromRequired(dereferenced) :
     Never()
   ) as never
 }
diff --git a/src/type/omit/omit.ts b/src/type/omit/omit.ts
index afba211c..a4d119ce 100644
--- a/src/type/omit/omit.ts
+++ b/src/type/omit/omit.ts
@@ -147,7 +147,7 @@ function OmitResolve<Properties extends TSchema, PropertyKeys extends PropertyKe
 // ------------------------------------------------------------------
 // TOmit
 //
-// This mapping logic is to overly complex because of the decision 
+// This mapping logic is to overly complex because of the decision
 // to use PropertyKey[] as the default selector. The PropertyKey[]
 // did make TMapped types simpler to implement, but a non-TSchema
 // selector makes supporting TComputed awkward as it requires
@@ -189,4 +189,4 @@ export function Omit(type: any, key: any, options?: SchemaOptions): any {
     (isTypeRef && !isKeyRef) ? Computed('Omit', [type, typeKey], options) :
     CreateType({ ...OmitResolve(type, propertyKeys), ...options })
   ) as never
-}
\ No newline at end of file
+}
diff --git a/src/type/partial/partial.ts b/src/type/partial/partial.ts
index 5fbc95a7..3cfb4872 100644
--- a/src/type/partial/partial.ts
+++ b/src/type/partial/partial.ts
@@ -82,10 +82,10 @@ type TFromProperties<Properties extends TProperties> = Evaluate<{
     TOptional<Properties[K]>
 }>
 // prettier-ignore
-function FromProperties<Properties extends TProperties>(T: Properties): TFromProperties<Properties> {
-  const properties = {} as TProperties
-  for(const K of globalThis.Object.getOwnPropertyNames(T)) properties[K] = Optional(T[K])
-  return properties as never
+function FromProperties<Properties extends TProperties>(properties: Properties): TFromProperties<Properties> {
+  const partialProperties = {} as TProperties
+  for(const K of globalThis.Object.getOwnPropertyNames(properties)) partialProperties[K] = Optional(properties[K])
+  return partialProperties as never
 }
 // ------------------------------------------------------------------
 // FromObject
@@ -100,7 +100,19 @@ function FromObject<Type extends TObject>(T: Type): TFromObject<Type> {
   const properties = FromProperties(T['properties'])
   return Object(properties, options) as never
 }
-
+// ------------------------------------------------------------------
+// FromRest
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromRest<R, [...Result, TPartial<L>]>
+    : Result
+)
+// prettier-ignore
+function FromRest<Types extends TSchema[]>(types: [...Types]): TFromRest<Types> {
+  return types.map(type => PartialResolve(type)) as never
+}
 // ------------------------------------------------------------------
 // PartialResolve
 // ------------------------------------------------------------------
@@ -116,41 +128,28 @@ function PartialResolve<Type extends TSchema>(type: Type): TPartial<Type> {
   ) as never
 }
 // ------------------------------------------------------------------
-// FromRest
-// ------------------------------------------------------------------
-// prettier-ignore
-type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (
-  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, [...Result, TPartial<L>]>
-    : Result
-)
-// prettier-ignore
-function FromRest<Types extends TSchema[]>(types: [...Types]): TFromRest<Types> {
-  return types.map(L => PartialResolve(L)) as never
-}
-// ------------------------------------------------------------------
 // TPartial
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TPartial<T extends TSchema> = (
   T extends TRecursive<infer Type extends TSchema> ? TRecursive<TPartial<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>> :
-  T extends TRef<infer Ref extends string> ? TFromRef<Ref> :
   TObject<{}>
 )
 /** `[Json]` Constructs a type where all properties are optional */
-export function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>
+export function Partial<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>
 /** `[Json]` Constructs a type where all properties are optional */
-export function Partial<T extends TSchema>(T: T, options?: SchemaOptions): TPartial<T>
+export function Partial<Type extends TSchema>(type: Type, options?: SchemaOptions): TPartial<Type>
 /** `[Json]` Constructs a type where all properties are optional */
-export function Partial(T: TSchema, options?: SchemaOptions): any {
-  if (IsMappedResult(T)) {
-    return PartialFromMappedResult(T, options)
+export function Partial(type: TSchema, options?: SchemaOptions): any {
+  if (IsMappedResult(type)) {
+    return PartialFromMappedResult(type, options)
   } else {
     // special: mapping types require overridable options
-    return CreateType({ ...PartialResolve(T), ...options })
+    return CreateType({ ...PartialResolve(type), ...options })
   }
 }
diff --git a/src/type/pick/pick.ts b/src/type/pick/pick.ts
index ab26dcf3..9f7abcd6 100644
--- a/src/type/pick/pick.ts
+++ b/src/type/pick/pick.ts
@@ -141,7 +141,7 @@ function PickResolve<Properties extends TSchema, PropertyKeys extends PropertyKe
 // ------------------------------------------------------------------
 // TPick
 //
-// This mapping logic is to overly complex because of the decision 
+// This mapping logic is to overly complex because of the decision
 // to use PropertyKey[] as the default selector. The PropertyKey[]
 // did make TMapped types simpler to implement, but a non-TSchema
 // selector makes supporting TComputed awkward as it requires
diff --git a/src/type/required/index.ts b/src/type/required/index.ts
index 04146ef5..e6d6901f 100644
--- a/src/type/required/index.ts
+++ b/src/type/required/index.ts
@@ -27,5 +27,4 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 export * from './required-from-mapped-result'
-export * from './required-ref'
 export * from './required'
diff --git a/src/type/required/required-ref.ts b/src/type/required/required-ref.ts
deleted file mode 100644
index e606b7a4..00000000
--- a/src/type/required/required-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 TRequiredRef<Ref extends string = string> extends TSchema {
-  [Kind]: 'RequiredRef'
-  static: unknown
-  $ref: Ref
-}
-/** Creates a RequiredRef */
-export function RequiredRef<Ref extends string>($ref: Ref, options?: SchemaOptions): TRequiredRef<Ref> {
-  return CreateType({ [Kind]: 'RequiredRef', $ref }, options) as never
-}
diff --git a/src/type/required/required.ts b/src/type/required/required.ts
index 1fefe7b4..35d2408d 100644
--- a/src/type/required/required.ts
+++ b/src/type/required/required.ts
@@ -31,34 +31,44 @@ import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Evaluate, Ensure } from '../helpers/index'
 import type { TMappedResult } from '../mapped/index'
 import { type TReadonlyOptional } from '../readonly-optional/index'
+import { type TComputed, Computed } from '../computed/index'
 import { type TOptional } from '../optional/index'
 import { type TReadonly } from '../readonly/index'
 import { type TRecursive } from '../recursive/index'
 import { type TObject, type TProperties, Object } from '../object/index'
 import { type TIntersect, Intersect } from '../intersect/index'
 import { type TUnion, Union } from '../union/index'
-import { type TRef } from '../ref/index'
+import { type TRef, Ref } from '../ref/index'
 import { OptionalKind, TransformKind } from '../symbols/index'
 import { Discard } from '../discard/index'
 import { RequiredFromMappedResult, type TRequiredFromMappedResult } from './required-from-mapped-result'
-import { RequiredRef, type TRequiredRef } from './required-ref'
 
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject, IsRef } from '../guard/kind'
+import { IsMappedResult, IsIntersect, IsUnion, IsObject, IsRef, IsComputed } from '../guard/kind'
+
 // ------------------------------------------------------------------
-// FromRest
+// FromComputed
 // ------------------------------------------------------------------
 // prettier-ignore
-type TFromRest<Types extends TSchema[], Acc extends TSchema[] = []> = (
-  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? TFromRest<R, [...Acc, TRequired<L>]>
-    : Acc
-)
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<
+  TComputed<'Required', [TComputed<Target, Parameters>]>
+>
 // prettier-ignore
-function FromRest<Types extends TSchema[]>(T: [...Types]) : TFromRest<Types> {
-  return T.map(L => RequiredResolve(L)) as never
+function FromComputed<Target extends string, Parameters extends TSchema[]>(target: Target, parameters: Parameters): TFromComputed<Target, Parameters> {
+  return Computed('Required', [Computed(target, parameters)]) as never
+}
+// ------------------------------------------------------------------
+// FromRef
+// ------------------------------------------------------------------
+// prettier-ignore
+type TFromRef<Ref extends string> = Ensure<
+  TComputed<'Required', [TRef<Ref>]>
+>
+// prettier-ignore
+function FromRef<Ref extends string>($ref: Ref): TFromRef<Ref> {
+  return Computed('Required', [Ref($ref)]) as never
 }
 // ------------------------------------------------------------------
 // FromProperties
@@ -72,10 +82,10 @@ type TFromProperties<Properties extends TProperties> = Evaluate<{
     Properties[K]
 }>
 // prettier-ignore
-function FromProperties<Properties extends TProperties>(T: Properties) {
-  const properties = {} as TProperties
-  for(const K of globalThis.Object.getOwnPropertyNames(T)) properties[K] = Discard(T[K], [OptionalKind]) as TSchema
-  return properties as never
+function FromProperties<Properties extends TProperties>(properties: Properties) {
+  const requiredProperties = {} as TProperties
+  for(const K of globalThis.Object.getOwnPropertyNames(properties)) requiredProperties[K] = Discard(properties[K], [OptionalKind]) as TSchema
+  return requiredProperties as never
 }
 // ------------------------------------------------------------------
 // FromObject
@@ -85,29 +95,35 @@ type TFromObject<Type extends TObject, Properties extends TProperties = Type['pr
   TFromProperties<Properties>
 )>>
 // prettier-ignore
-function FromObject<Type extends TObject>(T: Type): TFromObject<Type> {
-  const options = Discard(T, [TransformKind, '$id', 'required', 'properties'])
-  const properties = FromProperties(T['properties'])
+function FromObject<Type extends TObject>(type: Type): TFromObject<Type> {
+  const options = Discard(type, [TransformKind, '$id', 'required', 'properties'])
+  const properties = FromProperties(type['properties'])
   return Object(properties, options) as never
 }
 // ------------------------------------------------------------------
-// FromRef
+// FromRest
 // ------------------------------------------------------------------
-type TFromRef<Ref extends string> = Ensure<TRequiredRef<Ref>>
-
-function FromRef<Ref extends string>($ref: Ref): TFromRef<Ref> {
-  return RequiredRef($ref) as never
+// prettier-ignore
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (
+  Types extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? TFromRest<R, [...Result, TRequired<L>]>
+    : Result
+)
+// prettier-ignore
+function FromRest<Types extends TSchema[]>(types: [...Types]) : TFromRest<Types> {
+  return types.map(type => RequiredResolve(type)) as never
 }
 // ------------------------------------------------------------------
 // RequiredResolve
 // ------------------------------------------------------------------
 // prettier-ignore
-function RequiredResolve<T extends TSchema>(T: T): TRequired<T> {
+function RequiredResolve<Type extends TSchema>(type: Type): TRequired<Type> {
   return (
-    IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
-    IsUnion(T) ?  Union(FromRest(T.anyOf)) :
-    IsObject(T) ? FromObject(T) :
-    IsRef(T) ? FromRef(T.$ref) :
+    IsComputed(type) ? FromComputed(type.target, type.parameters) :
+    IsRef(type) ? FromRef(type.$ref) :
+    IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
+    IsUnion(type) ?  Union(FromRest(type.anyOf)) :
+    IsObject(type) ? FromObject(type) :
     Object({})
   ) as never
 }
@@ -116,23 +132,24 @@ function RequiredResolve<T extends TSchema>(T: T): TRequired<T> {
 // ------------------------------------------------------------------
 // prettier-ignore
 export type TRequired<T extends TSchema> = (
-  T extends TRecursive<infer S extends TSchema> ? TRecursive<TRequired<S>> :
-  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> :
-  T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> :
-  T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>> :
-  T extends TRef<infer S extends string> ? TFromRef<S> :
+  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>> :
   TObject<{}>
 )
 /** `[Json]` Constructs a type where all properties are required */
-export function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>
+export function Required<MappedResult extends TMappedResult>(mappedResult: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>
 /** `[Json]` Constructs a type where all properties are required */
-export function Required<T extends TSchema>(T: T, options?: SchemaOptions): TRequired<T>
+export function Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>
 /** `[Json]` Constructs a type where all properties are required */
-export function Required<T extends TSchema>(T: T, options?: SchemaOptions): never {
-  if (IsMappedResult(T)) {
-    return RequiredFromMappedResult(T, options) as never
+export function Required<Type extends TSchema>(type: Type, options?: SchemaOptions): never {
+  if (IsMappedResult(type)) {
+    return RequiredFromMappedResult(type, options) as never
   } else {
     // special: mapping types require overridable options
-    return CreateType({ ...RequiredResolve(T), ...options }) as never
+    return CreateType({ ...RequiredResolve(type), ...options }) as never
   }
 }
diff --git a/src/type/type/json.ts b/src/type/type/json.ts
index 5ff7073f..6a4bde30 100644
--- a/src/type/type/json.ts
+++ b/src/type/type/json.ts
@@ -236,12 +236,12 @@ export class JsonTypeBuilder {
     return Omit(schema, selector, options)
   }
   /** `[Json]` Constructs a type where all properties are optional */
-  public Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>
+  public Partial<MappedResult extends TMappedResult>(mappedResult: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>
   /** `[Json]` Constructs a type where all properties are optional */
-  public Partial<T extends TSchema>(schema: T, options?: SchemaOptions): TPartial<T>
+  public Partial<Type extends TSchema>(type: Type, options?: SchemaOptions): TPartial<Type>
   /** `[Json]` Constructs a type where all properties are optional */
-  public Partial(schema: TSchema, options?: SchemaOptions): any {
-    return Partial(schema, options)
+  public Partial(type: TSchema, options?: SchemaOptions): any {
+    return Partial(type, options)
   }
   /** `[Json]` Constructs a type whose keys are picked from the given type */
   public Pick<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TPick<Type, Key>
@@ -264,12 +264,12 @@ export class JsonTypeBuilder {
     return Ref($ref, options)
   }
   /** `[Json]` Constructs a type where all properties are required */
-  public Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>
+  public Required<MappedResult extends TMappedResult>(mappedResult: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>
   /** `[Json]` Constructs a type where all properties are required */
-  public Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>
+  public Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>
   /** `[Json]` Constructs a type where all properties are required */
-  public Required(schema: TSchema, options?: SchemaOptions): any {
-    return Required(schema, options)
+  public Required(type: TSchema, options?: SchemaOptions): any {
+    return Required(type, options)
   }
   /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
   public Rest<T extends TSchema>(schema: T): TRest<T> {