@sinclair/typebox 0.33.22 → 0.34.1

package/build/cjs/type/record/record.js

@@ -3,13 +3,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Record = Record;
 const type_1 = require("../create/type");
-const index_1 = require("../object/index");
-const index_2 = require("../never/index");
-const index_3 = require("../union/index");
-const index_4 = require("../template-literal/index");
-const index_5 = require("../patterns/index");
-const index_6 = require("../indexed/index");
-const index_7 = require("../symbols/index");
+const index_1 = require("../computed/index");
+const index_2 = require("../object/index");
+const index_3 = require("../never/index");
+const index_4 = require("../union/index");
+const index_5 = require("../template-literal/index");
+const index_6 = require("../patterns/index");
+const index_7 = require("../indexed/index");
+const index_8 = require("../symbols/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -24,7 +25,7 @@ const kind_1 = require("../guard/kind");
 // prettier-ignore
 function RecordCreateFromPattern(pattern, T, options) {
     return (0, type_1.CreateType)({
-        [index_7.Kind]: 'Record',
+        [index_8.Kind]: 'Record',
         type: 'object',
         patternProperties: { [pattern]: T }
     }, options);
@@ -37,17 +38,17 @@ function RecordCreateFromKeys(K, T, options) {
     const Acc = {};
     for (const K2 of K)
         Acc[K2] = T;
-    return (0, index_1.Object)(Acc, { ...options, [index_7.Hint]: 'Record' });
+    return (0, index_2.Object)(Acc, { ...options, [index_8.Hint]: 'Record' });
 }
 // prettier-ignore
 function FromTemplateLiteralKey(K, T, options) {
-    return ((0, index_4.IsTemplateLiteralFinite)(K)
-        ? RecordCreateFromKeys((0, index_6.IndexPropertyKeys)(K), T, options)
+    return ((0, index_5.IsTemplateLiteralFinite)(K)
+        ? RecordCreateFromKeys((0, index_7.IndexPropertyKeys)(K), T, options)
         : RecordCreateFromPattern(K.pattern, T, options));
 }
 // prettier-ignore
 function FromUnionKey(K, T, options) {
-    return RecordCreateFromKeys((0, index_6.IndexPropertyKeys)((0, index_3.Union)(K)), T, options);
+    return RecordCreateFromKeys((0, index_7.IndexPropertyKeys)((0, index_4.Union)(K)), T, options);
 }
 // prettier-ignore
 function FromLiteralKey(K, T, options) {
@@ -59,39 +60,41 @@ function FromRegExpKey(K, T, options) {
 }
 // prettier-ignore
 function FromStringKey(K, T, options) {
-    const pattern = (0, value_1.IsUndefined)(K.pattern) ? index_5.PatternStringExact : K.pattern;
+    const pattern = (0, value_1.IsUndefined)(K.pattern) ? index_6.PatternStringExact : K.pattern;
     return RecordCreateFromPattern(pattern, T, options);
 }
 // prettier-ignore
 function FromAnyKey(K, T, options) {
-    return RecordCreateFromPattern(index_5.PatternStringExact, T, options);
+    return RecordCreateFromPattern(index_6.PatternStringExact, T, options);
 }
 // prettier-ignore
 function FromNeverKey(K, T, options) {
-    return RecordCreateFromPattern(index_5.PatternNeverExact, T, options);
+    return RecordCreateFromPattern(index_6.PatternNeverExact, T, options);
 }
 // prettier-ignore
 function FromIntegerKey(_, T, options) {
-    return RecordCreateFromPattern(index_5.PatternNumberExact, T, options);
+    return RecordCreateFromPattern(index_6.PatternNumberExact, T, options);
 }
 // prettier-ignore
 function FromNumberKey(_, T, options) {
-    return RecordCreateFromPattern(index_5.PatternNumberExact, T, options);
+    return RecordCreateFromPattern(index_6.PatternNumberExact, T, options);
 }
 // ------------------------------------------------------------------
 // TRecordOrObject
 // ------------------------------------------------------------------
 /** `[Json]` Creates a Record type */
-function Record(K, T, options = {}) {
+function Record(key, type, options = {}) {
     // prettier-ignore
-    return ((0, kind_1.IsUnion)(K) ? FromUnionKey(K.anyOf, T, options) :
-        (0, kind_1.IsTemplateLiteral)(K) ? FromTemplateLiteralKey(K, T, options) :
-            (0, kind_1.IsLiteral)(K) ? FromLiteralKey(K.const, T, options) :
-                (0, kind_1.IsInteger)(K) ? FromIntegerKey(K, T, options) :
-                    (0, kind_1.IsNumber)(K) ? FromNumberKey(K, T, options) :
-                        (0, kind_1.IsRegExp)(K) ? FromRegExpKey(K, T, options) :
-                            (0, kind_1.IsString)(K) ? FromStringKey(K, T, options) :
-                                (0, kind_1.IsAny)(K) ? FromAnyKey(K, T, options) :
-                                    (0, kind_1.IsNever)(K) ? FromNeverKey(K, T, options) :
-                                        (0, index_2.Never)(options));
+    return ((0, kind_1.IsRef)(type) ? (0, index_1.Computed)('Record', [key, type]) :
+        (0, kind_1.IsRef)(key) ? (0, index_1.Computed)('Record', [key, type]) :
+            (0, kind_1.IsUnion)(key) ? FromUnionKey(key.anyOf, type, options) :
+                (0, kind_1.IsTemplateLiteral)(key) ? FromTemplateLiteralKey(key, type, options) :
+                    (0, kind_1.IsLiteral)(key) ? FromLiteralKey(key.const, type, options) :
+                        (0, kind_1.IsInteger)(key) ? FromIntegerKey(key, type, options) :
+                            (0, kind_1.IsNumber)(key) ? FromNumberKey(key, type, options) :
+                                (0, kind_1.IsRegExp)(key) ? FromRegExpKey(key, type, options) :
+                                    (0, kind_1.IsString)(key) ? FromStringKey(key, type, options) :
+                                        (0, kind_1.IsAny)(key) ? FromAnyKey(key, type, options) :
+                                            (0, kind_1.IsNever)(key) ? FromNeverKey(key, type, options) :
+                                                (0, index_3.Never)(options));
 }

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

@@ -1,12 +1,9 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
-import type { Static } from '../static/index';
 import { Kind } from '../symbols/index';
-export interface TRef<T extends TSchema = TSchema> extends TSchema {
+export interface TRef<Ref extends string = string> extends TSchema {
     [Kind]: 'Ref';
-    static: Static<T, this['params']>;
-    $ref: string;
+    static: unknown;
+    $ref: Ref;
 }
 /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-export declare function Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
-/** `[Json]` Creates a Ref type. */
-export declare function Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
+export declare function Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>;

package/build/cjs/type/ref/ref.js

@@ -4,15 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ref = Ref;
 const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
-// ------------------------------------------------------------------
-// ValueGuard
-// ------------------------------------------------------------------
-const value_1 = require("../guard/value");
-/** `[Json]` Creates a Ref type. */
-function Ref(unresolved, options) {
-    if ((0, value_1.IsString)(unresolved))
-        return (0, type_1.CreateType)({ [index_1.Kind]: 'Ref', $ref: unresolved }, options);
-    if ((0, value_1.IsUndefined)(unresolved.$id))
-        throw new Error('Reference target type must specify an $id');
-    return (0, type_1.CreateType)({ [index_1.Kind]: 'Ref', $ref: unresolved.$id }, options);
+/** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+function Ref($ref, options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Ref', $ref }, options);
 }

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

@@ -2,21 +2,25 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Evaluate, Ensure } from '../helpers/index';
 import type { TMappedResult } from '../mapped/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
+import { type TComputed } from '../computed/index';
 import { type TOptional } from '../optional/index';
 import { type TReadonly } from '../readonly/index';
 import { type TRecursive } from '../recursive/index';
+import { type TObject, type TProperties } from '../object/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
-import { type TObject, type TProperties } from '../object/index';
+import { type TRef } from '../ref/index';
 import { type TRequiredFromMappedResult } from './required-from-mapped-result';
-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/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/static/static.d.ts

@@ -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/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) {