@sinclair/typebox 0.33.22 → 0.34.1

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

@@ -2,21 +2,25 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Evaluate, Ensure } from '../helpers/index.mjs';
 import type { TMappedResult } from '../mapped/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
+import { type TComputed } from '../computed/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import { type TReadonly } from '../readonly/index.mjs';
 import { type TRecursive } from '../recursive/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
-import { type TObject, type TProperties } from '../object/index.mjs';
+import { type TRef } from '../ref/index.mjs';
 import { type TRequiredFromMappedResult } from './required-from-mapped-result.mjs';
-type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TRequired<L>]> : Acc);
-type TFromProperties<T extends TProperties> = Evaluate<{
-    [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : T[K] extends (TReadonly<infer S>) ? TReadonly<S> : T[K] extends (TOptional<infer S>) ? S : T[K];
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<'Required', [TComputed<Target, Parameters>]>>;
+type TFromRef<Ref extends string> = Ensure<TComputed<'Required', [TRef<Ref>]>>;
+type TFromProperties<Properties extends TProperties> = Evaluate<{
+    [K in keyof Properties]: Properties[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : Properties[K] extends (TReadonly<infer S>) ? TReadonly<S> : Properties[K] extends (TOptional<infer S>) ? S : Properties[K];
 }>;
-type TFromObject<T extends TObject, Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
-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>> : TObject<{}>);
+type TFromObject<Type extends TObject, Properties extends TProperties = Type['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Result, TRequired<L>]> : Result);
+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 */
-export declare function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
+export declare function Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>;
 /** `[Json]` Constructs a type where all properties are required */
-export declare function Required<T extends TSchema>(T: T, options?: SchemaOptions): TRequired<T>;
+export declare function Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>;
 export {};

package/build/esm/type/required/required.mjs

@@ -1,48 +1,60 @@
 import { CreateType } from '../create/type.mjs';
+import { Computed } from '../computed/index.mjs';
+import { Object } from '../object/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
-import { Object } from '../object/index.mjs';
+import { Ref } from '../ref/index.mjs';
 import { OptionalKind, TransformKind } from '../symbols/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { RequiredFromMappedResult } from './required-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/kind.mjs';
+import { IsMappedResult, IsIntersect, IsUnion, IsObject, IsRef, IsComputed } from '../guard/kind.mjs';
+// prettier-ignore
+function FromComputed(target, parameters) {
+    return Computed('Required', [Computed(target, parameters)]);
+}
 // prettier-ignore
-function FromRest(T) {
-    return T.map(L => RequiredResolve(L));
+function FromRef($ref) {
+    return Computed('Required', [Ref($ref)]);
 }
 // prettier-ignore
-function FromProperties(T) {
-    const Acc = {};
-    for (const K of globalThis.Object.getOwnPropertyNames(T))
-        Acc[K] = Discard(T[K], [OptionalKind]);
-    return Acc;
+function FromProperties(properties) {
+    const requiredProperties = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(properties))
+        requiredProperties[K] = Discard(properties[K], [OptionalKind]);
+    return requiredProperties;
 }
 // prettier-ignore
-function FromObject(T) {
-    const options = Discard(T, [TransformKind, '$id', 'required', 'properties']);
-    const properties = FromProperties(T['properties']);
+function FromObject(type) {
+    const options = Discard(type, [TransformKind, '$id', 'required', 'properties']);
+    const properties = FromProperties(type['properties']);
     return Object(properties, options);
 }
+// prettier-ignore
+function FromRest(types) {
+    return types.map(type => RequiredResolve(type));
+}
 // ------------------------------------------------------------------
 // RequiredResolve
 // ------------------------------------------------------------------
 // prettier-ignore
-function RequiredResolve(T) {
-    return (IsIntersect(T) ? Intersect(FromRest(T.allOf)) :
-        IsUnion(T) ? Union(FromRest(T.anyOf)) :
-            IsObject(T) ? FromObject(T) :
-                Object({}));
+function RequiredResolve(type) {
+    return (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({}));
 }
 /** `[Json]` Constructs a type where all properties are required */
-export function Required(T, options) {
-    if (IsMappedResult(T)) {
-        return RequiredFromMappedResult(T, options);
+export function Required(type, options) {
+    if (IsMappedResult(type)) {
+        return RequiredFromMappedResult(type, options);
     }
     else {
         // special: mapping types require overridable options
-        return CreateType({ ...RequiredResolve(T), ...options });
+        return CreateType({ ...RequiredResolve(type), ...options });
     }
 }

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

@@ -23,7 +23,7 @@ export type TDecodeProperties<T extends TProperties> = {
     [K in keyof T]: TDecodeType<T[K]>;
 };
 export type TDecodeRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TDecodeRest<R, [...Acc, TDecodeType<L>]> : Acc;
-export type TDecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<TDecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<TDecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? TArray<TDecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<TDecodeRest<P>, TDecodeType<R>> : T extends TEnum<infer S> ? TEnum<S> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<TDecodeRest<P>, TDecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TDecodeRest<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<TDecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<TDecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<TDecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<TDecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, TDecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<TDecodeType<S>> : T extends TRef<infer S extends TSchema> ? TRef<TDecodeType<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TDecodeRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TDecodeRest<S>> : T);
+export type TDecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<TDecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<TDecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? TArray<TDecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<TDecodeRest<P>, TDecodeType<R>> : T extends TEnum<infer S> ? TEnum<S> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<TDecodeRest<P>, TDecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TDecodeRest<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<TDecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<TDecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<TDecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<TDecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, TDecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<TDecodeType<S>> : T extends TRef<infer S extends string> ? TRef<S> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TDecodeRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TDecodeRest<S>> : T);
 export type StaticDecodeIsAny<T> = boolean extends (T extends TSchema ? true : false) ? true : false;
 /** Creates an decoded static type from a TypeBox type */
 export type StaticDecode<T extends TSchema, P extends unknown[] = []> = StaticDecodeIsAny<T> extends true ? unknown : Static<TDecodeType<T>, P>;

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

@@ -12,5 +12,5 @@ export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     maxItems: number;
 }
 /** `[Json]` Creates a Tuple type */
-export declare function Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
+export declare function Tuple<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): TTuple<Types>;
 export {};

package/build/esm/type/tuple/tuple.mjs

@@ -1,9 +1,9 @@
 import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a Tuple type */
-export function Tuple(items, options) {
+export function Tuple(types, options) {
     // 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 }, options);
+    return CreateType(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);
 }

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

@@ -20,33 +20,33 @@ import { type TVoid } from '../void/index.mjs';
 /** JavaScript Type Builder with Static Resolution for TypeScript */
 export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
     /** `[JavaScript]` Creates a AsyncIterator type */
-    AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;
+    AsyncIterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TAsyncIterator<Type>;
     /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-    Awaited<T extends TSchema>(schema: T, options?: SchemaOptions): TAwaited<T>;
+    Awaited<Type extends TSchema>(schema: Type, options?: SchemaOptions): TAwaited<Type>;
     /** `[JavaScript]` Creates a BigInt type */
     BigInt(options?: BigIntOptions): TBigInt;
     /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-    ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
+    ConstructorParameters<Type extends TConstructor>(schema: Type, options?: SchemaOptions): TConstructorParameters<Type>;
     /** `[JavaScript]` Creates a Constructor type */
-    Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
+    Constructor<Parameters extends TSchema[], InstanceType extends TSchema>(parameters: [...Parameters], instanceType: InstanceType, options?: SchemaOptions): TConstructor<Parameters, InstanceType>;
     /** `[JavaScript]` Creates a Date type */
     Date(options?: DateOptions): TDate;
     /** `[JavaScript]` Creates a Function type */
-    Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
+    Function<Parameters extends TSchema[], ReturnType extends TSchema>(parameters: [...Parameters], returnType: ReturnType, options?: SchemaOptions): TFunction<Parameters, ReturnType>;
     /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-    InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
+    InstanceType<Type extends TConstructor>(schema: Type, options?: SchemaOptions): TInstanceType<Type>;
     /** `[JavaScript]` Creates an Iterator type */
-    Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T>;
+    Iterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TIterator<Type>;
     /** `[JavaScript]` Extracts the Parameters from the given Function type */
-    Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;
+    Parameters<Type extends TFunction>(schema: Type, options?: SchemaOptions): TParameters<Type>;
     /** `[JavaScript]` Creates a Promise type */
-    Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
+    Promise<Type extends TSchema>(item: Type, options?: SchemaOptions): TPromise<Type>;
     /** `[JavaScript]` Creates a RegExp type */
     RegExp(pattern: string, options?: RegExpOptions): TRegExp;
     /** `[JavaScript]` Creates a RegExp type */
     RegExp(regex: RegExp, options?: RegExpOptions): TRegExp;
     /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-    ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
+    ReturnType<Type extends TFunction>(type: Type, options?: SchemaOptions): TReturnType<Type>;
     /** `[JavaScript]` Creates a Symbol type */
     Symbol(options?: SchemaOptions): TSymbol;
     /** `[JavaScript]` Creates a Undefined type */

package/build/esm/type/type/javascript.mjs

@@ -35,16 +35,16 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
         return ConstructorParameters(schema, options);
     }
     /** `[JavaScript]` Creates a Constructor type */
-    Constructor(parameters, returns, options) {
-        return Constructor(parameters, returns, options);
+    Constructor(parameters, instanceType, options) {
+        return Constructor(parameters, instanceType, options);
     }
     /** `[JavaScript]` Creates a Date type */
     Date(options = {}) {
         return Date(options);
     }
     /** `[JavaScript]` Creates a Function type */
-    Function(parameters, returns, options) {
-        return FunctionType(parameters, returns, options);
+    Function(parameters, returnType, options) {
+        return FunctionType(parameters, returnType, options);
     }
     /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
     InstanceType(schema, options) {
@@ -67,8 +67,8 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
         return RegExp(unresolved, options);
     }
     /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-    ReturnType(schema, options) {
-        return ReturnType(schema, options);
+    ReturnType(type, options) {
+        return ReturnType(type, options);
     }
     /** `[JavaScript]` Creates a Symbol type */
     Symbol(options) {

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

@@ -3,28 +3,28 @@ import { type TArray, type ArrayOptions } from '../array/index.mjs';
 import { type TBoolean } from '../boolean/index.mjs';
 import { type TComposite } from '../composite/index.mjs';
 import { type TConst } from '../const/index.mjs';
-import { type TDeref } from '../deref/index.mjs';
 import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index.mjs';
 import { type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index.mjs';
 import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index.mjs';
 import { type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from '../extract/index.mjs';
-import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from '../indexed/index.mjs';
+import { TIndex, type TIndexPropertyKeys } from '../indexed/index.mjs';
 import { type IntegerOptions, type TInteger } from '../integer/index.mjs';
 import { Intersect, type IntersectOptions } from '../intersect/index.mjs';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index.mjs';
-import { type TKeyOf, type TKeyOfFromMappedResult } from '../keyof/index.mjs';
+import { type TKeyOf } from '../keyof/index.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TMappedFunction, type TMapped, type TMappedResult } from '../mapped/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { type TNot } from '../not/index.mjs';
 import { type TNull } from '../null/index.mjs';
 import { type TMappedKey } from '../mapped/index.mjs';
+import { TModule } from '../module/index.mjs';
 import { type TNumber, type NumberOptions } from '../number/index.mjs';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
-import { type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from '../omit/index.mjs';
+import { type TOmit } from '../omit/index.mjs';
 import { type TOptionalWithFlag, type TOptionalFromMappedResult } from '../optional/index.mjs';
 import { type TPartial, type TPartialFromMappedResult } from '../partial/index.mjs';
-import { type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from '../pick/index.mjs';
+import { type TPick } from '../pick/index.mjs';
 import { type TReadonlyWithFlag, type TReadonlyFromMappedResult } from '../readonly/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type TRecordOrObject } from '../record/index.mjs';
@@ -33,7 +33,6 @@ import { type TRef } from '../ref/index.mjs';
 import { type TRequired, type TRequiredFromMappedResult } from '../required/index.mjs';
 import { type TRest } from '../rest/index.mjs';
 import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
-import { type TStrict } from '../strict/index.mjs';
 import { type TString, type StringOptions } from '../string/index.mjs';
 import { type TTemplateLiteral, type TTemplateLiteralKind, type TTemplateLiteralSyntax } from '../template-literal/index.mjs';
 import { TransformDecodeBuilder } from '../transform/index.mjs';
@@ -43,38 +42,28 @@ import { type TUnknown } from '../unknown/index.mjs';
 import { type TUnsafe, type UnsafeOptions } from '../unsafe/index.mjs';
 /** Json Type Builder with Static Resolution for TypeScript */
 export declare class JsonTypeBuilder {
-    /**
-     * @deprecated `[Json]` Omits compositing symbols from this schema. It is recommended
-     * to use the JSON parse/stringify to remove compositing symbols if needed. This
-     * is how Strict works internally.
-     *
-     * ```typescript
-     * JSON.parse(JSON.stringify(Type.String()))
-     * ```
-     */
-    Strict<T extends TSchema>(schema: T): TStrict<T>;
     /** `[Json]` Creates a Readonly and Optional property */
-    ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T>;
+    ReadonlyOptional<Type extends TSchema>(type: Type): TReadonlyOptional<Type>;
     /** `[Json]` Creates a Readonly property */
-    Readonly<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TReadonlyFromMappedResult<T, F>;
+    Readonly<Type extends TMappedResult, Flag extends boolean>(type: Type, enable: Flag): TReadonlyFromMappedResult<Type, Flag>;
     /** `[Json]` Creates a Readonly property */
-    Readonly<T extends TSchema, F extends boolean>(schema: T, enable: F): TReadonlyWithFlag<T, F>;
+    Readonly<Type extends TSchema, Flag extends boolean>(type: Type, enable: Flag): TReadonlyWithFlag<Type, Flag>;
     /** `[Json]` Creates a Optional property */
-    Readonly<T extends TMappedResult>(schema: T): TReadonlyFromMappedResult<T, true>;
+    Readonly<Type extends TMappedResult>(type: Type): TReadonlyFromMappedResult<Type, true>;
     /** `[Json]` Creates a Readonly property */
-    Readonly<T extends TSchema>(schema: T): TReadonlyWithFlag<T, true>;
+    Readonly<Type extends TSchema>(type: Type): TReadonlyWithFlag<Type, true>;
     /** `[Json]` Creates a Optional property */
-    Optional<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TOptionalFromMappedResult<T, F>;
+    Optional<Type extends TMappedResult, Flag extends boolean>(type: Type, enable: Flag): TOptionalFromMappedResult<Type, Flag>;
     /** `[Json]` Creates a Optional property */
-    Optional<T extends TSchema, F extends boolean>(schema: T, enable: F): TOptionalWithFlag<T, F>;
+    Optional<Type extends TSchema, Flag extends boolean>(type: Type, enable: Flag): TOptionalWithFlag<Type, Flag>;
     /** `[Json]` Creates a Optional property */
-    Optional<T extends TMappedResult>(schema: T): TOptionalFromMappedResult<T, true>;
+    Optional<Type extends TMappedResult>(type: Type): TOptionalFromMappedResult<Type, true>;
     /** `[Json]` Creates a Optional property */
-    Optional<T extends TSchema>(schema: T): TOptionalWithFlag<T, true>;
+    Optional<Type extends TSchema>(type: Type): TOptionalWithFlag<Type, true>;
     /** `[Json]` Creates an Any type */
     Any(options?: SchemaOptions): TAny;
     /** `[Json]` Creates an Array type */
-    Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;
+    Array<Type extends TSchema>(items: Type, options?: ArrayOptions): TArray<Type>;
     /** `[Json]` Creates a Boolean type */
     Boolean(options?: SchemaOptions): TBoolean;
     /** `[Json]` Intrinsic function to Capitalize LiteralString types */
@@ -83,8 +72,6 @@ export declare class JsonTypeBuilder {
     Composite<T extends TSchema[]>(schemas: [...T], options?: ObjectOptions): TComposite<T>;
     /** `[JavaScript]` Creates a readonly const type from the given value. */
     Const</* const (not supported in 4.0) */ T>(value: T, options?: SchemaOptions): TConst<T>;
-    /** `[Json]` Creates a dereferenced type */
-    Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
     /** `[Json]` Creates a Enum type */
     Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;
     /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
@@ -106,87 +93,77 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>;
+    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 */
-    Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
+    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 */
-    Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
+    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 */
-    Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;
+    Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
     /** `[Json]` Creates an Integer type */
     Integer(options?: IntegerOptions): TInteger;
     /** `[Json]` Creates an Intersect type */
-    Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T>;
+    Intersect<Types extends TSchema[]>(types: [...Types], options?: IntersectOptions): Intersect<Types>;
     /** `[Json]` Creates a KeyOf type */
-    KeyOf<T extends TMappedResult>(schema: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
-    /** `[Json]` Creates a KeyOf type */
-    KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
+    KeyOf<Type extends TSchema>(type: Type, options?: SchemaOptions): TKeyOf<Type>;
     /** `[Json]` Creates a Literal type */
-    Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
+    Literal<LiteralValue extends TLiteralValue>(literalValue: LiteralValue, options?: SchemaOptions): TLiteral<LiteralValue>;
     /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TLowercase<T>;
+    Lowercase<Type extends TSchema>(type: Type, options?: SchemaOptions): TLowercase<Type>;
     /** `[Json]` Creates a Mapped object type */
     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;
     /** `[Json]` Creates a Mapped object type */
     Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
+    /** `[Json]` Creates a Type Definition Module. */
+    Module<Properties extends TProperties>(properties: Properties): TModule<Properties>;
     /** `[Json]` Creates a Never type */
     Never(options?: SchemaOptions): TNever;
     /** `[Json]` Creates a Not type */
-    Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;
+    Not<T extends TSchema>(type: T, options?: SchemaOptions): TNot<T>;
     /** `[Json]` Creates a Null type */
     Null(options?: SchemaOptions): TNull;
     /** `[Json]` Creates a Number type */
     Number(options?: NumberOptions): TNumber;
     /** `[Json]` Creates an Object type */
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TOmitFromMappedResult<T, K>;
-    /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TOmitFromMappedKey<T, K>;
-    /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
-    /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
-    /** `[Json]` Constructs a type where all properties are optional */
-    Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>;
-    /** `[Json]` Constructs a type where all properties are optional */
-    Partial<T extends TSchema>(schema: T, options?: SchemaOptions): TPartial<T>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>;
+    Omit<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TOmit<Type, Key>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TPickFromMappedKey<T, K>;
+    Omit<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TOmit<Type, Key>;
+    /** `[Json]` Constructs a type where all properties are optional */
+    Partial<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>;
+    /** `[Json]` Constructs a type where all properties are optional */
+    Partial<Type extends TSchema>(type: Type, options?: SchemaOptions): TPartial<Type>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+    Pick<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TPick<Type, Key>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
+    Pick<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TPick<Type, Key>;
     /** `[Json]` Creates a Record type */
-    Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): TRecordOrObject<K, T>;
+    Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: ObjectOptions): TRecordOrObject<Key, Value>;
     /** `[Json]` Creates a Recursive type */
     Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
-    /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-    Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
     /** `[Json]` Creates a Ref type. */
-    Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
+    Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>;
     /** `[Json]` Constructs a type where all properties are required */
-    Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
+    Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>;
     /** `[Json]` Constructs a type where all properties are required */
-    Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
+    Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>;
     /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-    Rest<T extends TSchema>(schema: T): TRest<T>;
+    Rest<Type extends TSchema>(type: Type): TRest<Type>;
     /** `[Json]` Creates a String type */
     String(options?: StringOptions): TString;
     /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-    TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>;
+    TemplateLiteral<Syntax extends string>(syntax: Syntax, options?: SchemaOptions): TTemplateLiteralSyntax<Syntax>;
     /** `[Json]` Creates a TemplateLiteral type */
-    TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
+    TemplateLiteral<Kinds extends TTemplateLiteralKind[]>(kinds: [...Kinds], options?: SchemaOptions): TTemplateLiteral<Kinds>;
     /** `[Json]` Creates a Transform type */
-    Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;
+    Transform<Type extends TSchema>(type: Type): TransformDecodeBuilder<Type>;
     /** `[Json]` Creates a Tuple type */
-    Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
+    Tuple<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): TTuple<Types>;
     /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TUncapitalize<T>;
+    Uncapitalize<Type extends TSchema>(type: Type, options?: SchemaOptions): TUncapitalize<Type>;
     /** `[Json]` Creates a Union type */
-    Union<T extends TSchema[]>(schemas: [...T], options?: SchemaOptions): Union<T>;
+    Union<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): Union<Types>;
     /** `[Json]` Creates an Unknown type */
     Unknown(options?: SchemaOptions): TUnknown;
     /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */