@sinclair/typebox 0.34.16 → 0.34.17

package/build/esm/type/guard/kind.mjs

@@ -12,6 +12,10 @@ export function IsOptional(value) {
 export function IsAny(value) {
     return IsKindOf(value, 'Any');
 }
+/** `[Kind-Only]` Returns true if the given value is TArgument */
+export function IsArgument(value) {
+    return IsKindOf(value, 'Argument');
+}
 /** `[Kind-Only]` Returns true if the given value is TArray */
 export function IsArray(value) {
     return IsKindOf(value, 'Array');
@@ -192,6 +196,7 @@ export function IsKind(value) {
 export function IsSchema(value) {
     // prettier-ignore
     return (IsAny(value) ||
+        IsArgument(value) ||
         IsArray(value) ||
         IsBoolean(value) ||
         IsBigInt(value) ||

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

@@ -1,15 +1,12 @@
 import { Kind, Hint, TransformKind } from '../symbols/index.mjs';
 import { TypeBoxError } from '../error/index.mjs';
 import { TransformOptions } from '../transform/index.mjs';
-import type { TTemplateLiteral } from '../template-literal/index.mjs';
+import type { TAny } from '../any/index.mjs';
+import type { TArgument } from '../argument/index.mjs';
 import type { TArray } from '../array/index.mjs';
+import type { TAsyncIterator } from '../async-iterator/index.mjs';
 import type { TBoolean } from '../boolean/index.mjs';
 import type { TComputed } from '../computed/index.mjs';
-import type { TRecord } from '../record/index.mjs';
-import type { TString } from '../string/index.mjs';
-import type { TUnion } from '../union/index.mjs';
-import type { TAny } from '../any/index.mjs';
-import type { TAsyncIterator } from '../async-iterator/index.mjs';
 import type { TBigInt } from '../bigint/index.mjs';
 import type { TConstructor } from '../constructor/index.mjs';
 import type { TFunction } from '../function/index.mjs';
@@ -27,13 +24,17 @@ import type { TObject, TProperties } from '../object/index.mjs';
 import type { TOptional } from '../optional/index.mjs';
 import type { TPromise } from '../promise/index.mjs';
 import type { TReadonly } from '../readonly/index.mjs';
+import type { TRecord } from '../record/index.mjs';
 import type { TRef } from '../ref/index.mjs';
 import type { TRegExp } from '../regexp/index.mjs';
 import type { TSchema } from '../schema/index.mjs';
+import type { TString } from '../string/index.mjs';
 import type { TSymbol } from '../symbol/index.mjs';
+import type { TTemplateLiteral } from '../template-literal/index.mjs';
 import type { TTuple } from '../tuple/index.mjs';
 import type { TUint8Array } from '../uint8array/index.mjs';
 import type { TUndefined } from '../undefined/index.mjs';
+import type { TUnion } from '../union/index.mjs';
 import type { TUnknown } from '../unknown/index.mjs';
 import type { TUnsafe } from '../unsafe/index.mjs';
 import type { TVoid } from '../void/index.mjs';
@@ -47,6 +48,8 @@ export declare function IsReadonly<T extends TSchema>(value: T): value is TReado
 export declare function IsOptional<T extends TSchema>(value: T): value is TOptional<T>;
 /** Returns true if the given value is TAny */
 export declare function IsAny(value: unknown): value is TAny;
+/** Returns true if the given value is TArgument */
+export declare function IsArgument(value: unknown): value is TArgument;
 /** Returns true if the given value is TArray */
 export declare function IsArray(value: unknown): value is TArray;
 /** Returns true if the given value is TAsyncIterator */

package/build/esm/type/guard/type.mjs

@@ -4,6 +4,7 @@ import { TypeBoxError } from '../error/index.mjs';
 export class TypeGuardUnknownTypeError extends TypeBoxError {
 }
 const KnownTypes = [
+    'Argument',
     'Any',
     'Array',
     'AsyncIterator',
@@ -103,6 +104,12 @@ export function IsAny(value) {
     return (IsKindOf(value, 'Any') &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TArgument */
+export function IsArgument(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Argument') &&
+        ValueGuard.IsNumber(value.index));
+}
 /** Returns true if the given value is TArray */
 export function IsArray(value) {
     return (IsKindOf(value, 'Array') &&
@@ -463,6 +470,7 @@ export function IsKind(value) {
 export function IsSchema(value) {
     // prettier-ignore
     return (ValueGuard.IsObject(value)) && (IsAny(value) ||
+        IsArgument(value) ||
         IsArray(value) ||
         IsBoolean(value) ||
         IsBigInt(value) ||

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

@@ -1,4 +1,5 @@
 export * from './any/index.mjs';
+export * from './argument/index.mjs';
 export * from './array/index.mjs';
 export * from './async-iterator/index.mjs';
 export * from './awaited/index.mjs';
@@ -21,6 +22,7 @@ export * from './guard/index.mjs';
 export * from './helpers/index.mjs';
 export * from './indexed/index.mjs';
 export * from './instance-type/index.mjs';
+export * from './instantiate/index.mjs';
 export * from './integer/index.mjs';
 export * from './intersect/index.mjs';
 export * from './intrinsic/index.mjs';

package/build/esm/type/index.mjs

@@ -1,4 +1,5 @@
 export * from './any/index.mjs';
+export * from './argument/index.mjs';
 export * from './array/index.mjs';
 export * from './async-iterator/index.mjs';
 export * from './awaited/index.mjs';
@@ -21,6 +22,7 @@ export * from './guard/index.mjs';
 export * from './helpers/index.mjs';
 export * from './indexed/index.mjs';
 export * from './instance-type/index.mjs';
+export * from './instantiate/index.mjs';
 export * from './integer/index.mjs';
 export * from './intersect/index.mjs';
 export * from './intrinsic/index.mjs';

package/build/esm/type/instantiate/index.d.mts

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

package/build/esm/type/instantiate/index.mjs

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

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

@@ -0,0 +1,25 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TArgument } from '../argument/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
+import { type TReadonly } from '../readonly/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
+import { type TRemap, type TMapping as TRemapMapping } from '../remap/index.mjs';
+type TInstantiateArgument<Argument extends TArgument, Type extends TSchema, IsArgumentReadonly extends number = Argument extends TReadonly<TSchema> ? 1 : 0, IsArgumentOptional extends number = Argument extends TOptional<TSchema> ? 1 : 0, Result extends TSchema = ([
+    IsArgumentReadonly,
+    IsArgumentOptional
+] extends [1, 1] ? TReadonlyOptional<Type> : [
+    IsArgumentReadonly,
+    IsArgumentOptional
+] extends [0, 1] ? TOptional<Type> : [
+    IsArgumentReadonly,
+    IsArgumentOptional
+] extends [1, 0] ? TReadonly<Type> : Type)> = Result;
+interface TInstantiateArguments<Arguments extends TSchema[]> extends TRemapMapping {
+    output: (this['input'] extends TArgument<infer Index extends number> ? Index extends keyof Arguments ? Arguments[Index] extends TSchema ? TInstantiateArgument<this['input'], Arguments[Index]> : TNever : TNever : this['input']);
+}
+/** `[JavaScript]` Instantiates a type with the given parameters */
+export type TInstantiate<Type extends TSchema, Arguments extends TSchema[]> = (TRemap<Type, TInstantiateArguments<Arguments>>);
+/** `[JavaScript]` Instantiates a type with the given parameters */
+export declare function Instantiate<Type extends TSchema, Arguments extends TSchema[]>(type: Type, args: [...Arguments]): TInstantiate<Type, Arguments>;
+export {};

package/build/esm/type/instantiate/instantiate.mjs

@@ -0,0 +1,28 @@
+import { Never } from '../never/index.mjs';
+import { ReadonlyOptional } from '../readonly-optional/index.mjs';
+import { Readonly } from '../readonly/index.mjs';
+import { Optional } from '../optional/index.mjs';
+import { Remap } from '../remap/index.mjs';
+import * as KindGuard from '../guard/kind.mjs';
+// prettier-ignore
+function InstantiateArgument(argument, type) {
+    const isReadonly = KindGuard.IsReadonly(argument);
+    const isOptional = KindGuard.IsOptional(argument);
+    return (isReadonly && isOptional ? ReadonlyOptional(type) :
+        isReadonly && !isOptional ? Readonly(type) :
+            !isReadonly && isOptional ? Optional(type) :
+                type);
+}
+/** `[JavaScript]` Instantiates a type with the given parameters */
+// prettier-ignore
+export function Instantiate(type, args) {
+    return Remap(type, (type) => {
+        return KindGuard.IsArgument(type)
+            ? type.index in args
+                ? KindGuard.IsSchema(args[type.index])
+                    ? InstantiateArgument(type, args[type.index])
+                    : Never()
+                : Never()
+            : type;
+    });
+}

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

@@ -3,6 +3,7 @@ import type { TSchema } from '../schema/index.mjs';
 import type { Static } from '../static/index.mjs';
 import type { Evaluate, Ensure, Assert } from '../helpers/index.mjs';
 import { type TAny } from '../any/index.mjs';
+import { type TBoolean } from '../boolean/index.mjs';
 import { type TComputed } from '../computed/index.mjs';
 import { type TEnumRecord, type TEnum } from '../enum/index.mjs';
 import { type TInteger } from '../integer/index.mjs';
@@ -38,6 +39,10 @@ type TFromRegExpKey<_Key extends TRegExp, Type extends TSchema> = (Ensure<TRecor
 type TFromStringKey<_Key extends TString, Type extends TSchema> = (Ensure<TRecord<TString, Type>>);
 type TFromAnyKey<_Key extends TAny, Type extends TSchema> = (Ensure<TRecord<TAny, Type>>);
 type TFromNeverKey<_Key extends TNever, Type extends TSchema> = (Ensure<TRecord<TNever, Type>>);
+type TFromBooleanKey<_Key extends TBoolean, Type extends TSchema> = (Ensure<TObject<{
+    true: Type;
+    false: Type;
+}>>);
 type TFromIntegerKey<_Key extends TSchema, Type extends TSchema> = (Ensure<TRecord<TNumber, Type>>);
 type TFromNumberKey<_Key extends TSchema, Type extends TSchema> = (Ensure<TRecord<TNumber, Type>>);
 type RecordStatic<Key extends TSchema, Type extends TSchema, P extends unknown[]> = (Evaluate<{
@@ -52,7 +57,17 @@ export interface TRecord<Key extends TSchema = TSchema, Type extends TSchema = T
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [Key, TComputed<Target, Parameters>]> : Key extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [TComputed<Target, Parameters>, Type]> : Key extends TRef<infer Ref extends string> ? TComputed<'Record', [TRef<Ref>, Type]> : Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer Enum extends TEnumRecord> ? TFromEnumKey<Enum, Type> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Type> : Key extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteralKey<Value, Type> : Key extends TInteger ? TFromIntegerKey<Key, Type> : Key extends TNumber ? TFromNumberKey<Key, Type> : Key extends TRegExp ? TFromRegExpKey<Key, Type> : Key extends TString ? TFromStringKey<Key, Type> : Key extends TAny ? TFromAnyKey<Key, Type> : Key extends TNever ? TFromNeverKey<Key, Type> : TNever);
+export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [Key, TComputed<Target, Parameters>]> : Key extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [TComputed<Target, Parameters>, Type]> : Key extends TRef<infer Ref extends string> ? TComputed<'Record', [TRef<Ref>, Type]> : Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer Enum extends TEnumRecord> ? TFromEnumKey<Enum, Type> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Type> : Key extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteralKey<Value, Type> : Key extends TBoolean ? TFromBooleanKey<Key, Type> : Key extends TInteger ? TFromIntegerKey<Key, Type> : Key extends TNumber ? TFromNumberKey<Key, Type> : Key extends TRegExp ? TFromRegExpKey<Key, Type> : Key extends TString ? TFromStringKey<Key, Type> : Key extends TAny ? TFromAnyKey<Key, Type> : Key extends TNever ? TFromNeverKey<Key, Type> : TNever);
 /** `[Json]` Creates a Record type */
 export declare function Record<Key extends TSchema, Type extends TSchema>(key: Key, type: Type, options?: ObjectOptions): TRecordOrObject<Key, Type>;
+/** Gets the Records Pattern */
+export declare function RecordPattern(record: TRecord): string;
+/** Gets the Records Key Type */
+export type TRecordKey<Type extends TRecord> = (Type extends TRecord<infer Key extends TSchema, TSchema> ? (Key extends TNumber ? TNumber : Key extends TString ? TString : TString) : TString);
+/** Gets the Records Key Type */
+export declare function RecordKey<Type extends TRecord>(type: Type): TRecordKey<Type>;
+/** Gets a Record Value Type */
+export type TRecordValue<Type extends TRecord> = (Type extends TRecord<TSchema, infer Value extends TSchema> ? Value : TNever);
+/** Gets a Record Value Type */
+export declare function RecordValue<Type extends TRecord>(type: Type): TRecordValue<Type>;
 export {};

package/build/esm/type/record/record.mjs

@@ -2,8 +2,10 @@ import { CreateType } from '../create/type.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
 import { Computed } from '../computed/index.mjs';
 import { Never } from '../never/index.mjs';
+import { Number } from '../number/index.mjs';
 import { Object } from '../object/index.mjs';
 import { Ref } from '../ref/index.mjs';
+import { String } from '../string/index.mjs';
 import { Union } from '../union/index.mjs';
 import { IsTemplateLiteralFinite } from '../template-literal/index.mjs';
 import { PatternStringExact, PatternNumberExact, PatternNeverExact } from '../patterns/index.mjs';
@@ -15,7 +17,7 @@ import { IsUndefined } from '../guard/value.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion, IsRef, IsComputed } from '../guard/kind.mjs';
+import { IsInteger, IsLiteral, IsAny, IsBoolean, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion, IsRef, IsComputed } from '../guard/kind.mjs';
 // ------------------------------------------------------------------
 // RecordCreateFromPattern
 // ------------------------------------------------------------------
@@ -65,6 +67,10 @@ function FromNeverKey(_key, type, options) {
     return RecordCreateFromPattern(PatternNeverExact, type, options);
 }
 // prettier-ignore
+function FromBooleanKey(_key, type, options) {
+    return Object({ true: type, false: type }, options);
+}
+// prettier-ignore
 function FromIntegerKey(_key, type, options) {
     return RecordCreateFromPattern(PatternNumberExact, type, options);
 }
@@ -84,11 +90,32 @@ export function Record(key, type, options = {}) {
                 IsUnion(key) ? FromUnionKey(key.anyOf, type, options) :
                     IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) :
                         IsLiteral(key) ? FromLiteralKey(key.const, type, options) :
-                            IsInteger(key) ? FromIntegerKey(key, type, options) :
-                                IsNumber(key) ? FromNumberKey(key, type, options) :
-                                    IsRegExp(key) ? FromRegExpKey(key, type, options) :
-                                        IsString(key) ? FromStringKey(key, type, options) :
-                                            IsAny(key) ? FromAnyKey(key, type, options) :
-                                                IsNever(key) ? FromNeverKey(key, type, options) :
-                                                    Never(options));
+                            IsBoolean(key) ? FromBooleanKey(key, type, options) :
+                                IsInteger(key) ? FromIntegerKey(key, type, options) :
+                                    IsNumber(key) ? FromNumberKey(key, type, options) :
+                                        IsRegExp(key) ? FromRegExpKey(key, type, options) :
+                                            IsString(key) ? FromStringKey(key, type, options) :
+                                                IsAny(key) ? FromAnyKey(key, type, options) :
+                                                    IsNever(key) ? FromNeverKey(key, type, options) :
+                                                        Never(options));
+}
+// ------------------------------------------------------------------
+// Record Utilities
+// ------------------------------------------------------------------
+/** Gets the Records Pattern */
+export function RecordPattern(record) {
+    return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
+}
+/** Gets the Records Key Type */
+// prettier-ignore
+export function RecordKey(type) {
+    const pattern = RecordPattern(type);
+    return (pattern === PatternStringExact ? String() :
+        pattern === PatternNumberExact ? Number() :
+            String({ pattern }));
+}
+/** Gets a Record Value Type */
+// prettier-ignore
+export function RecordValue(type) {
+    return type.patternProperties[RecordPattern(type)];
 }

package/build/esm/type/remap/index.d.mts

@@ -0,0 +1 @@
+export * from './remap.mjs';

package/build/esm/type/remap/index.mjs

@@ -0,0 +1 @@
+export * from './remap.mjs';

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

@@ -0,0 +1,19 @@
+import * as t from '@sinclair/typebox.mjs';
+export type TCallback = (schema: t.TSchema) => t.TSchema;
+export interface TMapping {
+    input: unknown;
+    output: unknown;
+}
+type TApply<Type extends t.TSchema, Mapping extends TMapping, Mapped = (Mapping & {
+    input: Type;
+})['output'], Result = Mapped extends t.TSchema ? Mapped : never> = Result;
+type TFromProperties<Properties extends t.TProperties, Mapping extends TMapping, Result extends t.TProperties = {
+    [Key in keyof Properties]: TRemap<Properties[Key], Mapping>;
+}> = Result;
+type TFromTypes<Types extends t.TSchema[], Mapping extends TMapping, Result extends t.TSchema[] = []> = (Types extends [infer Left extends t.TSchema, ...infer Right extends t.TSchema[]] ? TFromTypes<Right, Mapping, [...Result, TRemap<Left, Mapping>]> : Result);
+type TFromType<Type extends t.TSchema, Mapping extends TMapping, Result extends t.TSchema = (TApply<Type, Mapping>)> = Result;
+/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
+export type TRemap<Type extends t.TSchema, Mapping extends TMapping, Mapped extends t.TSchema = TFromType<Type, Mapping>, Result extends t.TSchema = (Mapped extends t.TConstructor<infer Parameters extends t.TSchema[], infer ReturnType extends t.TSchema> ? t.TConstructor<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> : Mapped extends t.TFunction<infer Parameters extends t.TSchema[], infer ReturnType extends t.TSchema> ? t.TFunction<TFromTypes<Parameters, Mapping>, TFromType<ReturnType, Mapping>> : Mapped extends t.TIntersect<infer Types extends t.TSchema[]> ? t.TIntersect<TFromTypes<Types, Mapping>> : Mapped extends t.TUnion<infer Types extends t.TSchema[]> ? t.TUnion<TFromTypes<Types, Mapping>> : Mapped extends t.TTuple<infer Types extends t.TSchema[]> ? t.TTuple<TFromTypes<Types, Mapping>> : Mapped extends t.TArray<infer Type extends t.TSchema> ? t.TArray<TFromType<Type, Mapping>> : Mapped extends t.TAsyncIterator<infer Type extends t.TSchema> ? t.TAsyncIterator<TFromType<Type, Mapping>> : Mapped extends t.TIterator<infer Type extends t.TSchema> ? t.TIterator<TFromType<Type, Mapping>> : Mapped extends t.TPromise<infer Type extends t.TSchema> ? t.TPromise<TFromType<Type, Mapping>> : Mapped extends t.TObject<infer Properties extends t.TProperties> ? t.TObject<TFromProperties<Properties, Mapping>> : Mapped extends t.TRecord<infer Key extends t.TSchema, infer Value extends t.TSchema> ? t.TRecordOrObject<TFromType<Key, Mapping>, TFromType<Value, Mapping>> : Mapped)> = Result;
+/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
+export declare function Remap(type: t.TSchema, callback: TCallback): t.TSchema;
+export {};

package/build/esm/type/remap/remap.mjs

@@ -0,0 +1,31 @@
+import * as t from '@sinclair/typebox.mjs';
+function FromProperties(properties, func) {
+    return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+        return { ...result, [key]: Remap(properties[key], func) };
+    }, {});
+}
+function FromTypes(types, callback) {
+    return types.map((type) => Remap(type, callback));
+}
+function FromType(type, callback) {
+    return callback(type);
+}
+/** `[Internal]` Applies a recursive conditional remapping of a type and its sub type constituents */
+// prettier-ignore
+export function Remap(type, callback) {
+    // Map incoming type
+    const mapped = t.CloneType(FromType(type, callback));
+    // Return remapped interior
+    return (t.KindGuard.IsConstructor(type) ? t.Constructor(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
+        t.KindGuard.IsFunction(type) ? t.Function(FromTypes(type.parameters, callback), FromType(type.returns, callback), mapped) :
+            t.KindGuard.IsIntersect(type) ? t.Intersect(FromTypes(type.allOf, callback), mapped) :
+                t.KindGuard.IsUnion(type) ? t.Union(FromTypes(type.anyOf, callback), mapped) :
+                    t.KindGuard.IsTuple(type) ? t.Tuple(FromTypes(type.items || [], callback), mapped) :
+                        t.KindGuard.IsArray(type) ? t.Array(FromType(type.items, callback), mapped) :
+                            t.KindGuard.IsAsyncIterator(type) ? t.AsyncIterator(FromType(type.items, callback), mapped) :
+                                t.KindGuard.IsIterator(type) ? t.Iterator(FromType(type.items, callback), mapped) :
+                                    t.KindGuard.IsPromise(type) ? t.Promise(FromType(type.items, callback), mapped) :
+                                        t.KindGuard.IsObject(type) ? t.Object(FromProperties(type.properties, callback), mapped) :
+                                            t.KindGuard.IsRecord(type) ? t.Record(FromType(t.RecordKey(type), callback), FromType(t.RecordValue(type), callback), mapped) :
+                                                t.CloneType(mapped));
+}

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

@@ -1,4 +1,5 @@
 import { JsonTypeBuilder } from './json.mjs';
+import { type TArgument } from '../argument/index.mjs';
 import { type TAsyncIterator } from '../async-iterator/index.mjs';
 import { type TAwaited } from '../awaited/index.mjs';
 import { type TBigInt, type BigIntOptions } from '../bigint/index.mjs';
@@ -7,6 +8,7 @@ import { type TConstructorParameters } from '../constructor-parameters/index.mjs
 import { type TDate, type DateOptions } from '../date/index.mjs';
 import { type TFunction } from '../function/index.mjs';
 import { type TInstanceType } from '../instance-type/index.mjs';
+import { type TInstantiate } from '../instantiate/index.mjs';
 import { type TIterator } from '../iterator/index.mjs';
 import { type TParameters } from '../parameters/index.mjs';
 import { type TPromise } from '../promise/index.mjs';
@@ -19,6 +21,8 @@ import { type TUndefined } from '../undefined/index.mjs';
 import { type TVoid } from '../void/index.mjs';
 /** JavaScript Type Builder with Static Resolution for TypeScript */
 export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
+    /** `[JavaScript]` Creates a Generic Argument Type */
+    Argument<Index extends number>(index: Index): TArgument<Index>;
     /** `[JavaScript]` Creates a AsyncIterator type */
     AsyncIterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TAsyncIterator<Type>;
     /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
@@ -35,6 +39,8 @@ export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
     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<Type extends TSchema>(schema: Type, options?: SchemaOptions): TInstanceType<Type>;
+    /** `[JavaScript]` Instantiates a type with the given parameters */
+    Instantiate<Type extends TSchema, Parameters extends TSchema[]>(schema: Type, parameters: [...Parameters]): TInstantiate<Type, Parameters>;
     /** `[JavaScript]` Creates an Iterator type */
     Iterator<Type extends TSchema>(items: Type, options?: SchemaOptions): TIterator<Type>;
     /** `[JavaScript]` Extracts the Parameters from the given Function type */

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

@@ -1,4 +1,5 @@
 import { JsonTypeBuilder } from './json.mjs';
+import { Argument } from '../argument/index.mjs';
 import { AsyncIterator } from '../async-iterator/index.mjs';
 import { Awaited } from '../awaited/index.mjs';
 import { BigInt } from '../bigint/index.mjs';
@@ -7,6 +8,7 @@ import { ConstructorParameters } from '../constructor-parameters/index.mjs';
 import { Date } from '../date/index.mjs';
 import { Function as FunctionType } from '../function/index.mjs';
 import { InstanceType } from '../instance-type/index.mjs';
+import { Instantiate } from '../instantiate/index.mjs';
 import { Iterator } from '../iterator/index.mjs';
 import { Parameters } from '../parameters/index.mjs';
 import { Promise } from '../promise/index.mjs';
@@ -18,6 +20,10 @@ import { Undefined } from '../undefined/index.mjs';
 import { Void } from '../void/index.mjs';
 /** JavaScript Type Builder with Static Resolution for TypeScript */
 export class JavaScriptTypeBuilder extends JsonTypeBuilder {
+    /** `[JavaScript]` Creates a Generic Argument Type */
+    Argument(index) {
+        return Argument(index);
+    }
     /** `[JavaScript]` Creates a AsyncIterator type */
     AsyncIterator(items, options) {
         return AsyncIterator(items, options);
@@ -50,6 +56,10 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     InstanceType(schema, options) {
         return InstanceType(schema, options);
     }
+    /** `[JavaScript]` Instantiates a type with the given parameters */
+    Instantiate(schema, parameters) {
+        return Instantiate(schema, parameters);
+    }
     /** `[JavaScript]` Creates an Iterator type */
     Iterator(items, options) {
         return Iterator(items, options);

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

@@ -1,4 +1,5 @@
 export { Any } from '../any/index.mjs';
+export { Argument } from '../argument/index.mjs';
 export { Array } from '../array/index.mjs';
 export { AsyncIterator } from '../async-iterator/index.mjs';
 export { Awaited } from '../awaited/index.mjs';
@@ -16,6 +17,7 @@ export { Extract } from '../extract/index.mjs';
 export { Function } from '../function/index.mjs';
 export { Index } from '../indexed/index.mjs';
 export { InstanceType } from '../instance-type/index.mjs';
+export { Instantiate } from '../instantiate/index.mjs';
 export { Integer } from '../integer/index.mjs';
 export { Intersect } from '../intersect/index.mjs';
 export { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index.mjs';
@@ -41,6 +43,7 @@ export { Record } from '../record/index.mjs';
 export { Recursive } from '../recursive/index.mjs';
 export { Ref } from '../ref/index.mjs';
 export { RegExp } from '../regexp/index.mjs';
+export { Remap } from '../remap/index.mjs';
 export { Required } from '../required/index.mjs';
 export { Rest } from '../rest/index.mjs';
 export { ReturnType } from '../return-type/index.mjs';

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

@@ -2,6 +2,7 @@
 // Type: Module
 // ------------------------------------------------------------------
 export { Any } from '../any/index.mjs';
+export { Argument } from '../argument/index.mjs';
 export { Array } from '../array/index.mjs';
 export { AsyncIterator } from '../async-iterator/index.mjs';
 export { Awaited } from '../awaited/index.mjs';
@@ -19,6 +20,7 @@ export { Extract } from '../extract/index.mjs';
 export { Function } from '../function/index.mjs';
 export { Index } from '../indexed/index.mjs';
 export { InstanceType } from '../instance-type/index.mjs';
+export { Instantiate } from '../instantiate/index.mjs';
 export { Integer } from '../integer/index.mjs';
 export { Intersect } from '../intersect/index.mjs';
 export { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index.mjs';
@@ -44,6 +46,7 @@ export { Record } from '../record/index.mjs';
 export { Recursive } from '../recursive/index.mjs';
 export { Ref } from '../ref/index.mjs';
 export { RegExp } from '../regexp/index.mjs';
+export { Remap } from '../remap/index.mjs';
 export { Required } from '../required/index.mjs';
 export { Rest } from '../rest/index.mjs';
 export { ReturnType } from '../return-type/index.mjs';

package/build/esm/value/check/check.mjs

@@ -42,6 +42,9 @@ function IsDefined(value) {
 function FromAny(schema, references, value) {
     return true;
 }
+function FromArgument(schema, references, value) {
+    return true;
+}
 function FromArray(schema, references, value) {
     if (!IsArray(value))
         return false;
@@ -390,6 +393,8 @@ function Visit(schema, references, value) {
     switch (schema_[Kind]) {
         case 'Any':
             return FromAny(schema_, references_, value);
+        case 'Argument':
+            return FromArgument(schema_, references_, value);
         case 'Array':
             return FromArray(schema_, references_, value);
         case 'AsyncIterator':

package/build/esm/value/create/create.mjs

@@ -34,6 +34,9 @@ function FromAny(schema, references) {
         return {};
     }
 }
+function FromArgument(schema, references) {
+    return {};
+}
 function FromArray(schema, references) {
     if (schema.uniqueItems === true && !HasPropertyKey(schema, 'default')) {
         throw new ValueCreateError(schema, 'Array with the uniqueItems constraint requires a default value');
@@ -392,6 +395,8 @@ function Visit(schema, references) {
     switch (schema_[Kind]) {
         case 'Any':
             return FromAny(schema_, references_);
+        case 'Argument':
+            return FromArgument(schema_, references_);
         case 'Array':
             return FromArray(schema_, references_);
         case 'AsyncIterator':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.16",
+  "version": "0.34.17",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",