@sinclair/typebox 0.34.0 → 0.34.2

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/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

@@ -7,11 +7,11 @@ 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';
@@ -21,10 +21,10 @@ 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';
@@ -43,27 +43,27 @@ import { type TUnsafe, type UnsafeOptions } from '../unsafe/index.mjs';
 /** Json Type Builder with Static Resolution for TypeScript */
 export declare class JsonTypeBuilder {
     /** `[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 */
@@ -93,25 +93,23 @@ 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 */
@@ -121,59 +119,51 @@ export declare class JsonTypeBuilder {
     /** `[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. */
     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 */

package/build/esm/type/type/json.mjs

@@ -44,16 +44,16 @@ export class JsonTypeBuilder {
     // Modifiers
     // ------------------------------------------------------------------------
     /** `[Json]` Creates a Readonly and Optional property */
-    ReadonlyOptional(schema) {
-        return ReadonlyOptional(schema);
+    ReadonlyOptional(type) {
+        return ReadonlyOptional(type);
     }
     /** `[Json]` Creates a Readonly property */
-    Readonly(schema, enable) {
-        return Readonly(schema, enable ?? true);
+    Readonly(type, enable) {
+        return Readonly(type, enable ?? true);
     }
     /** `[Json]` Creates a Optional property */
-    Optional(schema, enable) {
-        return Optional(schema, enable ?? true);
+    Optional(type, enable) {
+        return Optional(type, enable ?? true);
     }
     // ------------------------------------------------------------------------
     // Types
@@ -63,8 +63,8 @@ export class JsonTypeBuilder {
         return Any(options);
     }
     /** `[Json]` Creates an Array type */
-    Array(schema, options) {
-        return Array(schema, options);
+    Array(items, options) {
+        return Array(items, options);
     }
     /** `[Json]` Creates a Boolean type */
     Boolean(options) {
@@ -99,28 +99,28 @@ export class JsonTypeBuilder {
         return Extract(type, union, options);
     }
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index(schema, unresolved, options) {
-        return Index(schema, unresolved, options);
+    Index(type, key, options) {
+        return Index(type, key, options);
     }
     /** `[Json]` Creates an Integer type */
     Integer(options) {
         return Integer(options);
     }
     /** `[Json]` Creates an Intersect type */
-    Intersect(T, options) {
-        return Intersect(T, options);
+    Intersect(types, options) {
+        return Intersect(types, options);
     }
     /** `[Json]` Creates a KeyOf type */
-    KeyOf(schema, options) {
-        return KeyOf(schema, options);
+    KeyOf(type, options) {
+        return KeyOf(type, options);
     }
     /** `[Json]` Creates a Literal type */
-    Literal(value, options) {
-        return Literal(value, options);
+    Literal(literalValue, options) {
+        return Literal(literalValue, options);
     }
     /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase(schema, options) {
-        return Lowercase(schema, options);
+    Lowercase(type, options) {
+        return Lowercase(type, options);
     }
     /** `[Json]` Creates a Mapped object type */
     Mapped(key, map, options) {
@@ -135,8 +135,8 @@ export class JsonTypeBuilder {
         return Never(options);
     }
     /** `[Json]` Creates a Not type */
-    Not(schema, options) {
-        return Not(schema, options);
+    Not(type, options) {
+        return Not(type, options);
     }
     /** `[Json]` Creates a Null type */
     Null(options) {
@@ -151,20 +151,20 @@ export class JsonTypeBuilder {
         return Object(properties, options);
     }
     /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit(schema, unresolved, options) {
-        return Omit(schema, unresolved, options);
+    Omit(schema, selector, options) {
+        return Omit(schema, selector, options);
     }
     /** `[Json]` Constructs a type where all properties are optional */
-    Partial(schema, options) {
-        return Partial(schema, options);
+    Partial(type, options) {
+        return Partial(type, options);
     }
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick(schema, unresolved, options) {
-        return Pick(schema, unresolved, options);
+    Pick(type, key, options) {
+        return Pick(type, key, options);
     }
     /** `[Json]` Creates a Record type */
-    Record(key, schema, options) {
-        return Record(key, schema, options);
+    Record(key, value, options) {
+        return Record(key, value, options);
     }
     /** `[Json]` Creates a Recursive type */
     Recursive(callback, options) {
@@ -175,12 +175,12 @@ export class JsonTypeBuilder {
         return Ref($ref, options);
     }
     /** `[Json]` Constructs a type where all properties are required */
-    Required(schema, options) {
-        return Required(schema, options);
+    Required(type, options) {
+        return Required(type, options);
     }
     /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-    Rest(schema) {
-        return Rest(schema);
+    Rest(type) {
+        return Rest(type);
     }
     /** `[Json]` Creates a String type */
     String(options) {
@@ -191,20 +191,20 @@ export class JsonTypeBuilder {
         return TemplateLiteral(unresolved, options);
     }
     /** `[Json]` Creates a Transform type */
-    Transform(schema) {
-        return Transform(schema);
+    Transform(type) {
+        return Transform(type);
     }
     /** `[Json]` Creates a Tuple type */
-    Tuple(items, options) {
-        return Tuple(items, options);
+    Tuple(types, options) {
+        return Tuple(types, options);
     }
     /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize(schema, options) {
-        return Uncapitalize(schema, options);
+    Uncapitalize(type, options) {
+        return Uncapitalize(type, options);
     }
     /** `[Json]` Creates a Union type */
-    Union(schemas, options) {
-        return Union(schemas, options);
+    Union(types, options) {
+        return Union(types, options);
     }
     /** `[Json]` Creates an Unknown type */
     Unknown(options) {

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

@@ -3,11 +3,11 @@ import { type TNever } from '../never/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import type { TReadonly } from '../readonly/index.mjs';
 import type { TUnion } from './union-type.mjs';
-type TIsUnionOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? true : TIsUnionOptional<R> : false);
-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 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 TResolveUnion<T extends TSchema[], R extends TSchema[] = TRemoveOptionalFromRest<T>> = (TIsUnionOptional<T> extends true ? TOptional<TUnion<R>> : TUnion<R>);
-export type TUnionEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TResolveUnion<T>);
+type TIsUnionOptional<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<TSchema> ? true : TIsUnionOptional<Right> : false);
+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);
+type TRemoveOptionalFromType<Type extends TSchema> = (Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType<Type>> : Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType<Type> : Type);
+type TResolveUnion<Types extends TSchema[], Result extends TSchema[] = TRemoveOptionalFromRest<Types>, IsOptional extends boolean = TIsUnionOptional<Types>> = (IsOptional extends true ? TOptional<TUnion<Result>> : TUnion<Result>);
+export type TUnionEvaluated<Types extends TSchema[]> = (Types extends [TSchema] ? Types[0] : Types extends [] ? TNever : TResolveUnion<Types>);
 /** `[Json]` Creates an evaluated Union type */
-export declare function UnionEvaluated<T extends TSchema[], R = TUnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R;
+export declare function UnionEvaluated<Types extends TSchema[], Result = TUnionEvaluated<Types>>(T: [...Types], options?: SchemaOptions): Result;
 export {};

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

@@ -9,27 +9,28 @@ import { UnionCreate } from './union-create.mjs';
 // ------------------------------------------------------------------
 import { IsOptional } from '../guard/kind.mjs';
 // prettier-ignore
-function IsUnionOptional(T) {
-    return T.some(L => IsOptional(L));
+function IsUnionOptional(types) {
+    return types.some(type => IsOptional(type));
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T) {
-    return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L);
+function RemoveOptionalFromRest(types) {
+    return types.map(left => IsOptional(left) ? RemoveOptionalFromType(left) : left);
 }
 // prettier-ignore
 function RemoveOptionalFromType(T) {
     return (Discard(T, [OptionalKind]));
 }
 // prettier-ignore
-function ResolveUnion(T, options) {
-    return (IsUnionOptional(T)
-        ? Optional(UnionCreate(RemoveOptionalFromRest(T), options))
-        : UnionCreate(RemoveOptionalFromRest(T), options));
+function ResolveUnion(types, options) {
+    const isOptional = IsUnionOptional(types);
+    return (isOptional
+        ? Optional(UnionCreate(RemoveOptionalFromRest(types), options))
+        : UnionCreate(RemoveOptionalFromRest(types), options));
 }
 /** `[Json]` Creates an evaluated Union type */
 export function UnionEvaluated(T, options) {
     // prettier-ignore
-    return (T.length === 0 ? Never(options) :
-        T.length === 1 ? CreateType(T[0], options) :
+    return (T.length === 1 ? CreateType(T[0], options) :
+        T.length === 0 ? Never(options) :
             ResolveUnion(T, options));
 }

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

@@ -3,4 +3,4 @@ import { type TNever } from '../never/index.mjs';
 import type { TUnion } from './union-type.mjs';
 export type Union<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TUnion<T>);
 /** `[Json]` Creates a Union type */
-export declare function Union<T extends TSchema[]>(T: [...T], options?: SchemaOptions): Union<T>;
+export declare function Union<Types extends TSchema[]>(types: [...Types], options?: SchemaOptions): Union<Types>;

package/build/esm/type/union/union.mjs

@@ -2,9 +2,9 @@ import { Never } from '../never/index.mjs';
 import { CreateType } from '../create/type.mjs';
 import { UnionCreate } from './union-create.mjs';
 /** `[Json]` Creates a Union type */
-export function Union(T, options) {
+export function Union(types, options) {
     // prettier-ignore
-    return (T.length === 0 ? Never(options) :
-        T.length === 1 ? CreateType(T[0], options) :
-            UnionCreate(T, options));
+    return (types.length === 0 ? Never(options) :
+        types.length === 1 ? CreateType(types[0], options) :
+            UnionCreate(types, options));
 }