@sinclair/typebox 0.34.0 → 0.34.1

package/build/cjs/type/required/required.js

@@ -3,50 +3,62 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Required = Required;
 const type_1 = require("../create/type");
-const index_1 = require("../intersect/index");
-const index_2 = require("../union/index");
-const index_3 = require("../object/index");
-const index_4 = require("../symbols/index");
-const index_5 = require("../discard/index");
+const index_1 = require("../computed/index");
+const index_2 = require("../object/index");
+const index_3 = require("../intersect/index");
+const index_4 = require("../union/index");
+const index_5 = require("../ref/index");
+const index_6 = require("../symbols/index");
+const index_7 = require("../discard/index");
 const required_from_mapped_result_1 = require("./required-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
-function FromRest(T) {
-    return T.map(L => RequiredResolve(L));
+function FromComputed(target, parameters) {
+    return (0, index_1.Computed)('Required', [(0, index_1.Computed)(target, parameters)]);
 }
 // prettier-ignore
-function FromProperties(T) {
-    const Acc = {};
-    for (const K of globalThis.Object.getOwnPropertyNames(T))
-        Acc[K] = (0, index_5.Discard)(T[K], [index_4.OptionalKind]);
-    return Acc;
+function FromRef($ref) {
+    return (0, index_1.Computed)('Required', [(0, index_5.Ref)($ref)]);
 }
 // prettier-ignore
-function FromObject(T) {
-    const options = (0, index_5.Discard)(T, [index_4.TransformKind, '$id', 'required', 'properties']);
-    const properties = FromProperties(T['properties']);
-    return (0, index_3.Object)(properties, options);
+function FromProperties(properties) {
+    const requiredProperties = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(properties))
+        requiredProperties[K] = (0, index_7.Discard)(properties[K], [index_6.OptionalKind]);
+    return requiredProperties;
+}
+// prettier-ignore
+function FromObject(type) {
+    const options = (0, index_7.Discard)(type, [index_6.TransformKind, '$id', 'required', 'properties']);
+    const properties = FromProperties(type['properties']);
+    return (0, index_2.Object)(properties, options);
+}
+// prettier-ignore
+function FromRest(types) {
+    return types.map(type => RequiredResolve(type));
 }
 // ------------------------------------------------------------------
 // RequiredResolve
 // ------------------------------------------------------------------
 // prettier-ignore
-function RequiredResolve(T) {
-    return ((0, kind_1.IsIntersect)(T) ? (0, index_1.Intersect)(FromRest(T.allOf)) :
-        (0, kind_1.IsUnion)(T) ? (0, index_2.Union)(FromRest(T.anyOf)) :
-            (0, kind_1.IsObject)(T) ? FromObject(T) :
-                (0, index_3.Object)({}));
+function RequiredResolve(type) {
+    return ((0, kind_1.IsComputed)(type) ? FromComputed(type.target, type.parameters) :
+        (0, kind_1.IsRef)(type) ? FromRef(type.$ref) :
+            (0, kind_1.IsIntersect)(type) ? (0, index_3.Intersect)(FromRest(type.allOf)) :
+                (0, kind_1.IsUnion)(type) ? (0, index_4.Union)(FromRest(type.anyOf)) :
+                    (0, kind_1.IsObject)(type) ? FromObject(type) :
+                        (0, index_2.Object)({}));
 }
 /** `[Json]` Constructs a type where all properties are required */
-function Required(T, options) {
-    if ((0, kind_1.IsMappedResult)(T)) {
-        return (0, required_from_mapped_result_1.RequiredFromMappedResult)(T, options);
+function Required(type, options) {
+    if ((0, kind_1.IsMappedResult)(type)) {
+        return (0, required_from_mapped_result_1.RequiredFromMappedResult)(type, options);
     }
     else {
         // special: mapping types require overridable options
-        return (0, type_1.CreateType)({ ...RequiredResolve(T), ...options });
+        return (0, type_1.CreateType)({ ...RequiredResolve(type), ...options });
     }
 }

package/build/cjs/type/tuple/tuple.d.ts

@@ -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/cjs/type/tuple/tuple.js

@@ -5,9 +5,9 @@ exports.Tuple = Tuple;
 const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates a Tuple type */
-function Tuple(items, options) {
+function Tuple(types, options) {
     // prettier-ignore
-    return (0, type_1.CreateType)(items.length > 0 ?
-        { [index_1.Kind]: 'Tuple', type: 'array', items, additionalItems: false, minItems: items.length, maxItems: items.length } :
-        { [index_1.Kind]: 'Tuple', type: 'array', minItems: items.length, maxItems: items.length }, options);
+    return (0, type_1.CreateType)(types.length > 0 ?
+        { [index_1.Kind]: 'Tuple', type: 'array', items: types, additionalItems: false, minItems: types.length, maxItems: types.length } :
+        { [index_1.Kind]: 'Tuple', type: 'array', minItems: types.length, maxItems: types.length }, options);
 }

package/build/cjs/type/type/javascript.d.ts

@@ -20,33 +20,33 @@ import { type TVoid } from '../void/index';
 /** 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/cjs/type/type/javascript.js

@@ -39,16 +39,16 @@ class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
         return (0, index_5.ConstructorParameters)(schema, options);
     }
     /** `[JavaScript]` Creates a Constructor type */
-    Constructor(parameters, returns, options) {
-        return (0, index_4.Constructor)(parameters, returns, options);
+    Constructor(parameters, instanceType, options) {
+        return (0, index_4.Constructor)(parameters, instanceType, options);
     }
     /** `[JavaScript]` Creates a Date type */
     Date(options = {}) {
         return (0, index_6.Date)(options);
     }
     /** `[JavaScript]` Creates a Function type */
-    Function(parameters, returns, options) {
-        return (0, index_7.Function)(parameters, returns, options);
+    Function(parameters, returnType, options) {
+        return (0, index_7.Function)(parameters, returnType, options);
     }
     /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
     InstanceType(schema, options) {
@@ -71,8 +71,8 @@ class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
         return (0, index_12.RegExp)(unresolved, options);
     }
     /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-    ReturnType(schema, options) {
-        return (0, index_13.ReturnType)(schema, options);
+    ReturnType(type, options) {
+        return (0, index_13.ReturnType)(type, options);
     }
     /** `[JavaScript]` Creates a Symbol type */
     Symbol(options) {

package/build/cjs/type/type/json.d.ts

@@ -7,11 +7,11 @@ import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index';
 import { type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index';
 import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index';
 import { type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from '../extract/index';
-import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from '../indexed/index';
+import { TIndex, type TIndexPropertyKeys } from '../indexed/index';
 import { type IntegerOptions, type TInteger } from '../integer/index';
 import { Intersect, type IntersectOptions } from '../intersect/index';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index';
-import { type TKeyOf, type TKeyOfFromMappedResult } from '../keyof/index';
+import { type TKeyOf } from '../keyof/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TMappedFunction, type TMapped, type TMappedResult } from '../mapped/index';
 import { type TNever } from '../never/index';
@@ -21,10 +21,10 @@ import { type TMappedKey } from '../mapped/index';
 import { TModule } from '../module/index';
 import { type TNumber, type NumberOptions } from '../number/index';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
-import { type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from '../omit/index';
+import { type TOmit } from '../omit/index';
 import { type TOptionalWithFlag, type TOptionalFromMappedResult } from '../optional/index';
 import { type TPartial, type TPartialFromMappedResult } from '../partial/index';
-import { type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from '../pick/index';
+import { type TPick } from '../pick/index';
 import { type TReadonlyWithFlag, type TReadonlyFromMappedResult } from '../readonly/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type TRecordOrObject } from '../record/index';
@@ -43,27 +43,27 @@ import { type TUnsafe, type UnsafeOptions } from '../unsafe/index';
 /** 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/cjs/type/type/json.js

@@ -48,16 +48,16 @@ class JsonTypeBuilder {
     // Modifiers
     // ------------------------------------------------------------------------
     /** `[Json]` Creates a Readonly and Optional property */
-    ReadonlyOptional(schema) {
-        return (0, index_28.ReadonlyOptional)(schema);
+    ReadonlyOptional(type) {
+        return (0, index_28.ReadonlyOptional)(type);
     }
     /** `[Json]` Creates a Readonly property */
-    Readonly(schema, enable) {
-        return (0, index_27.Readonly)(schema, enable ?? true);
+    Readonly(type, enable) {
+        return (0, index_27.Readonly)(type, enable ?? true);
     }
     /** `[Json]` Creates a Optional property */
-    Optional(schema, enable) {
-        return (0, index_24.Optional)(schema, enable ?? true);
+    Optional(type, enable) {
+        return (0, index_24.Optional)(type, enable ?? true);
     }
     // ------------------------------------------------------------------------
     // Types
@@ -67,8 +67,8 @@ class JsonTypeBuilder {
         return (0, index_1.Any)(options);
     }
     /** `[Json]` Creates an Array type */
-    Array(schema, options) {
-        return (0, index_2.Array)(schema, options);
+    Array(items, options) {
+        return (0, index_2.Array)(items, options);
     }
     /** `[Json]` Creates a Boolean type */
     Boolean(options) {
@@ -103,28 +103,28 @@ class JsonTypeBuilder {
         return (0, index_9.Extract)(type, union, options);
     }
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index(schema, unresolved, options) {
-        return (0, index_10.Index)(schema, unresolved, options);
+    Index(type, key, options) {
+        return (0, index_10.Index)(type, key, options);
     }
     /** `[Json]` Creates an Integer type */
     Integer(options) {
         return (0, index_11.Integer)(options);
     }
     /** `[Json]` Creates an Intersect type */
-    Intersect(T, options) {
-        return (0, index_12.Intersect)(T, options);
+    Intersect(types, options) {
+        return (0, index_12.Intersect)(types, options);
     }
     /** `[Json]` Creates a KeyOf type */
-    KeyOf(schema, options) {
-        return (0, index_14.KeyOf)(schema, options);
+    KeyOf(type, options) {
+        return (0, index_14.KeyOf)(type, options);
     }
     /** `[Json]` Creates a Literal type */
-    Literal(value, options) {
-        return (0, index_15.Literal)(value, options);
+    Literal(literalValue, options) {
+        return (0, index_15.Literal)(literalValue, options);
     }
     /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase(schema, options) {
-        return (0, index_13.Lowercase)(schema, options);
+    Lowercase(type, options) {
+        return (0, index_13.Lowercase)(type, options);
     }
     /** `[Json]` Creates a Mapped object type */
     Mapped(key, map, options) {
@@ -139,8 +139,8 @@ class JsonTypeBuilder {
         return (0, index_17.Never)(options);
     }
     /** `[Json]` Creates a Not type */
-    Not(schema, options) {
-        return (0, index_18.Not)(schema, options);
+    Not(type, options) {
+        return (0, index_18.Not)(type, options);
     }
     /** `[Json]` Creates a Null type */
     Null(options) {
@@ -155,20 +155,20 @@ class JsonTypeBuilder {
         return (0, index_22.Object)(properties, options);
     }
     /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit(schema, unresolved, options) {
-        return (0, index_23.Omit)(schema, unresolved, options);
+    Omit(schema, selector, options) {
+        return (0, index_23.Omit)(schema, selector, options);
     }
     /** `[Json]` Constructs a type where all properties are optional */
-    Partial(schema, options) {
-        return (0, index_25.Partial)(schema, options);
+    Partial(type, options) {
+        return (0, index_25.Partial)(type, options);
     }
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick(schema, unresolved, options) {
-        return (0, index_26.Pick)(schema, unresolved, options);
+    Pick(type, key, options) {
+        return (0, index_26.Pick)(type, key, options);
     }
     /** `[Json]` Creates a Record type */
-    Record(key, schema, options) {
-        return (0, index_29.Record)(key, schema, options);
+    Record(key, value, options) {
+        return (0, index_29.Record)(key, value, options);
     }
     /** `[Json]` Creates a Recursive type */
     Recursive(callback, options) {
@@ -179,12 +179,12 @@ class JsonTypeBuilder {
         return (0, index_31.Ref)($ref, options);
     }
     /** `[Json]` Constructs a type where all properties are required */
-    Required(schema, options) {
-        return (0, index_32.Required)(schema, options);
+    Required(type, options) {
+        return (0, index_32.Required)(type, options);
     }
     /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-    Rest(schema) {
-        return (0, index_33.Rest)(schema);
+    Rest(type) {
+        return (0, index_33.Rest)(type);
     }
     /** `[Json]` Creates a String type */
     String(options) {
@@ -195,20 +195,20 @@ class JsonTypeBuilder {
         return (0, index_35.TemplateLiteral)(unresolved, options);
     }
     /** `[Json]` Creates a Transform type */
-    Transform(schema) {
-        return (0, index_36.Transform)(schema);
+    Transform(type) {
+        return (0, index_36.Transform)(type);
     }
     /** `[Json]` Creates a Tuple type */
-    Tuple(items, options) {
-        return (0, index_37.Tuple)(items, options);
+    Tuple(types, options) {
+        return (0, index_37.Tuple)(types, options);
     }
     /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize(schema, options) {
-        return (0, index_13.Uncapitalize)(schema, options);
+    Uncapitalize(type, options) {
+        return (0, index_13.Uncapitalize)(type, options);
     }
     /** `[Json]` Creates a Union type */
-    Union(schemas, options) {
-        return (0, index_38.Union)(schemas, options);
+    Union(types, options) {
+        return (0, index_38.Union)(types, options);
     }
     /** `[Json]` Creates an Unknown type */
     Unknown(options) {

package/build/cjs/type/union/union-evaluated.d.ts

@@ -3,11 +3,11 @@ import { type TNever } from '../never/index';
 import { type TOptional } from '../optional/index';
 import type { TReadonly } from '../readonly/index';
 import type { TUnion } from './union-type';
-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/cjs/type/union/union-evaluated.js

@@ -13,27 +13,28 @@ const union_create_1 = require("./union-create");
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
-function IsUnionOptional(T) {
-    return T.some(L => (0, kind_1.IsOptional)(L));
+function IsUnionOptional(types) {
+    return types.some(type => (0, kind_1.IsOptional)(type));
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T) {
-    return T.map(L => (0, kind_1.IsOptional)(L) ? RemoveOptionalFromType(L) : L);
+function RemoveOptionalFromRest(types) {
+    return types.map(left => (0, kind_1.IsOptional)(left) ? RemoveOptionalFromType(left) : left);
 }
 // prettier-ignore
 function RemoveOptionalFromType(T) {
     return ((0, index_2.Discard)(T, [index_1.OptionalKind]));
 }
 // prettier-ignore
-function ResolveUnion(T, options) {
-    return (IsUnionOptional(T)
-        ? (0, index_4.Optional)((0, union_create_1.UnionCreate)(RemoveOptionalFromRest(T), options))
-        : (0, union_create_1.UnionCreate)(RemoveOptionalFromRest(T), options));
+function ResolveUnion(types, options) {
+    const isOptional = IsUnionOptional(types);
+    return (isOptional
+        ? (0, index_4.Optional)((0, union_create_1.UnionCreate)(RemoveOptionalFromRest(types), options))
+        : (0, union_create_1.UnionCreate)(RemoveOptionalFromRest(types), options));
 }
 /** `[Json]` Creates an evaluated Union type */
 function UnionEvaluated(T, options) {
     // prettier-ignore
-    return (T.length === 0 ? (0, index_3.Never)(options) :
-        T.length === 1 ? (0, type_1.CreateType)(T[0], options) :
+    return (T.length === 1 ? (0, type_1.CreateType)(T[0], options) :
+        T.length === 0 ? (0, index_3.Never)(options) :
             ResolveUnion(T, options));
 }

package/build/cjs/type/union/union.d.ts

@@ -3,4 +3,4 @@ import { type TNever } from '../never/index';
 import type { TUnion } from './union-type';
 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/cjs/type/union/union.js

@@ -6,9 +6,9 @@ const index_1 = require("../never/index");
 const type_1 = require("../create/type");
 const union_create_1 = require("./union-create");
 /** `[Json]` Creates a Union type */
-function Union(T, options) {
+function Union(types, options) {
     // prettier-ignore
-    return (T.length === 0 ? (0, index_1.Never)(options) :
-        T.length === 1 ? (0, type_1.CreateType)(T[0], options) :
-            (0, union_create_1.UnionCreate)(T, options));
+    return (types.length === 0 ? (0, index_1.Never)(options) :
+        types.length === 1 ? (0, type_1.CreateType)(types[0], options) :
+            (0, union_create_1.UnionCreate)(types, options));
 }