@sinclair/typebox 0.34.16 → 0.34.18

package/build/cjs/compiler/compiler.js

@@ -209,6 +209,9 @@ var TypeCompiler;
     function* FromAny(schema, references, value) {
         yield 'true';
     }
+    function* FromArgument(schema, references, value) {
+        yield 'true';
+    }
     function* FromArray(schema, references, value) {
         yield `Array.isArray(${value})`;
         const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')];
@@ -493,6 +496,8 @@ var TypeCompiler;
         switch (schema_[index_7.Kind]) {
             case 'Any':
                 return yield* FromAny(schema_, references_, value);
+            case 'Argument':
+                return yield* FromArgument(schema_, references_, value);
             case 'Array':
                 return yield* FromArray(schema_, references_, value);
             case 'AsyncIterator':

package/build/cjs/errors/errors.js

@@ -145,6 +145,7 @@ function Create(errorType, schema, path, value, errors = []) {
 // Types
 // --------------------------------------------------------------------------
 function* FromAny(schema, references, path, value) { }
+function* FromArgument(schema, references, path, value) { }
 function* FromArray(schema, references, path, value) {
     if (!(0, index_10.IsArray)(value)) {
         return yield Create(ValueErrorType.Array, schema, path, value);
@@ -521,6 +522,8 @@ function* Visit(schema, references, path, value) {
     switch (schema_[index_8.Kind]) {
         case 'Any':
             return yield* FromAny(schema_, references_, path, value);
+        case 'Argument':
+            return yield* FromArgument(schema_, references_, path, value);
         case 'Array':
             return yield* FromArray(schema_, references_, path, value);
         case 'AsyncIterator':

package/build/cjs/index.d.ts

@@ -9,6 +9,7 @@ export * from './type/sets/index';
 export * from './type/symbols/index';
 export * from './type/any/index';
 export * from './type/array/index';
+export * from './type/argument/index';
 export * from './type/async-iterator/index';
 export * from './type/awaited/index';
 export * from './type/bigint/index';
@@ -25,6 +26,7 @@ export * from './type/extract/index';
 export * from './type/function/index';
 export * from './type/indexed/index';
 export * from './type/instance-type/index';
+export * from './type/instantiate/index';
 export * from './type/integer/index';
 export * from './type/intersect/index';
 export * from './type/iterator/index';
@@ -50,6 +52,7 @@ export * from './type/record/index';
 export * from './type/recursive/index';
 export * from './type/ref/index';
 export * from './type/regexp/index';
+export * from './type/remap/index';
 export * from './type/required/index';
 export * from './type/rest/index';
 export * from './type/return-type/index';

package/build/cjs/index.js

@@ -32,6 +32,7 @@ __exportStar(require("./type/symbols/index"), exports);
 // ------------------------------------------------------------------
 __exportStar(require("./type/any/index"), exports);
 __exportStar(require("./type/array/index"), exports);
+__exportStar(require("./type/argument/index"), exports);
 __exportStar(require("./type/async-iterator/index"), exports);
 __exportStar(require("./type/awaited/index"), exports);
 __exportStar(require("./type/bigint/index"), exports);
@@ -48,6 +49,7 @@ __exportStar(require("./type/extract/index"), exports);
 __exportStar(require("./type/function/index"), exports);
 __exportStar(require("./type/indexed/index"), exports);
 __exportStar(require("./type/instance-type/index"), exports);
+__exportStar(require("./type/instantiate/index"), exports);
 __exportStar(require("./type/integer/index"), exports);
 __exportStar(require("./type/intersect/index"), exports);
 __exportStar(require("./type/iterator/index"), exports);
@@ -73,6 +75,7 @@ __exportStar(require("./type/record/index"), exports);
 __exportStar(require("./type/recursive/index"), exports);
 __exportStar(require("./type/ref/index"), exports);
 __exportStar(require("./type/regexp/index"), exports);
+__exportStar(require("./type/remap/index"), exports);
 __exportStar(require("./type/required/index"), exports);
 __exportStar(require("./type/rest/index"), exports);
 __exportStar(require("./type/return-type/index"), exports);

package/build/cjs/syntax/runtime.d.ts

@@ -2,7 +2,7 @@ import { Runtime } from '../parser/index';
 import * as t from '../type/index';
 export declare const Module: Runtime.Module<{
     Literal: Runtime.IUnion<t.TLiteral<string> | t.TLiteral<number> | t.TLiteral<boolean>>;
-    Keyword: Runtime.IUnion<t.TAny | t.TNever | t.TString | t.TBoolean | t.TNumber | t.TInteger | t.TBigInt | t.TNull | t.TSymbol | t.TUndefined | t.TUnknown | t.TVoid>;
+    Keyword: Runtime.IUnion<t.TAny | t.TBoolean | t.TBigInt | t.TNever | t.TString | t.TNumber | t.TInteger | t.TNull | t.TSymbol | t.TUndefined | t.TUnknown | t.TVoid>;
     KeyOf: Runtime.IUnion<boolean>;
     IndexArray: Runtime.IUnion<unknown[]>;
     Extends: Runtime.IUnion<unknown[]>;
@@ -31,6 +31,7 @@ export declare const Module: Runtime.Module<{
     Mapped: Runtime.ITuple<t.TLiteral<"Mapped types not supported">>;
     AsyncIterator: Runtime.ITuple<t.TAsyncIterator<t.TSchema>>;
     Iterator: Runtime.ITuple<t.TIterator<t.TSchema>>;
+    Argument: Runtime.ITuple<t.TNever | t.TArgument<number>>;
     Awaited: Runtime.ITuple<t.TSchema>;
     Array: Runtime.ITuple<t.TArray<t.TSchema>>;
     Record: Runtime.ITuple<t.TNever>;
@@ -51,5 +52,6 @@ export declare const Module: Runtime.Module<{
     Uncapitalize: Runtime.ITuple<t.TSchema>;
     Date: Runtime.IConst<t.TDate>;
     Uint8Array: Runtime.IConst<t.TUint8Array>;
+    GenericReference: Runtime.ITuple<t.TSchema>;
     Reference: Runtime.IIdent<t.TSchema>;
 }>;

package/build/cjs/syntax/runtime.js

@@ -34,16 +34,28 @@ function DestructureRight(values) {
         : [values, undefined];
 }
 // ------------------------------------------------------------------
-// Deref
+// Dereference
 // ------------------------------------------------------------------
-const Deref = (context, key) => {
+const Dereference = (context, key) => {
     return key in context ? context[key] : t.Ref(key);
 };
 // ------------------------------------------------------------------
+// GenericReference
+// ------------------------------------------------------------------
+function GenericReferenceMapping(results, context) {
+    const target = Dereference(context, results[0]);
+    return t.Instantiate(target, results[2]);
+}
+const GenericReference = index_1.Runtime.Tuple([index_1.Runtime.Ident(), index_1.Runtime.Const(LAngle), index_1.Runtime.Ref('Elements'), index_1.Runtime.Const(RAngle)], (results, context) => GenericReferenceMapping(results, context));
+// ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
+function ReferenceMapping(result, context) {
+    const target = Dereference(context, result);
+    return target;
+}
 // prettier-ignore
-const Reference = index_1.Runtime.Ident((value, context) => Deref(context, value));
+const Reference = index_1.Runtime.Ident((result, context) => ReferenceMapping(result, context));
 // ------------------------------------------------------------------
 // Literal
 // ------------------------------------------------------------------
@@ -135,6 +147,7 @@ const Base = index_1.Runtime.Union([
             index_1.Runtime.Ref('FunctionParameters'),
             index_1.Runtime.Ref('InstanceType'),
             index_1.Runtime.Ref('ReturnType'),
+            index_1.Runtime.Ref('Argument'),
             index_1.Runtime.Ref('Awaited'),
             index_1.Runtime.Ref('Array'),
             index_1.Runtime.Ref('Record'),
@@ -151,6 +164,7 @@ const Base = index_1.Runtime.Union([
             index_1.Runtime.Ref('Uncapitalize'),
             index_1.Runtime.Ref('Date'),
             index_1.Runtime.Ref('Uint8Array'),
+            index_1.Runtime.Ref('GenericReference'),
             index_1.Runtime.Ref('Reference')
         ])])
 ], BaseMapping);
@@ -417,6 +431,20 @@ const ReturnType = index_1.Runtime.Tuple([
     index_1.Runtime.Const(RAngle),
 ], value => t.ReturnType(value[2]));
 // ------------------------------------------------------------------
+// Argument
+// ------------------------------------------------------------------
+// prettier-ignore
+const Argument = index_1.Runtime.Tuple([
+    index_1.Runtime.Const('Argument'),
+    index_1.Runtime.Const(LAngle),
+    index_1.Runtime.Ref('Type'),
+    index_1.Runtime.Const(RAngle),
+], results => {
+    return t.KindGuard.IsLiteralNumber(results[2])
+        ? t.Argument(Math.trunc(results[2].const))
+        : t.Never();
+});
+// ------------------------------------------------------------------
 // Awaited
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -610,6 +638,7 @@ exports.Module = new index_1.Runtime.Module({
     Mapped,
     AsyncIterator,
     Iterator,
+    Argument,
     Awaited,
     Array,
     Record,
@@ -630,5 +659,6 @@ exports.Module = new index_1.Runtime.Module({
     Uncapitalize,
     Date,
     Uint8Array,
+    GenericReference,
     Reference,
 });

package/build/cjs/syntax/static.d.ts

@@ -41,9 +41,18 @@ type Delimit<Parser extends Static.IParser, Delimiter extends Static.IParser> =
     Static.Tuple<[Parser, DelimitTail<Parser, Delimiter>]>,
     Static.Tuple<[]>
 ], DelimitMapping>);
-type Deref<Context extends t.TProperties, Ref extends string> = (Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>);
+type Dereference<Context extends t.TProperties, Ref extends string> = (Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>);
+interface GenericReferenceMapping extends Static.IMapping {
+    output: this['context'] extends t.TProperties ? this['input'] extends [infer Reference extends string, LAngle, infer Parameters extends t.TSchema[], RAngle] ? t.TInstantiate<Dereference<this['context'], Reference>, [...Parameters]> : never : never;
+}
+type GenericReference = Static.Tuple<[
+    Static.Ident,
+    Static.Const<LAngle>,
+    Elements,
+    Static.Const<RAngle>
+], GenericReferenceMapping>;
 interface ReferenceMapping extends Static.IMapping {
-    output: this['context'] extends t.TProperties ? this['input'] extends string ? Deref<this['context'], this['input']> : never : never;
+    output: this['context'] extends t.TProperties ? this['input'] extends string ? Dereference<this['context'], this['input']> : never : never;
 }
 type Reference = Static.Ident<ReferenceMapping>;
 interface LiteralBooleanMapping extends Static.IMapping {
@@ -119,6 +128,7 @@ type Base = Static.Union<[
             Iterator,
             ConstructorParameters,
             FunctionParameters,
+            Argument,
             InstanceType,
             ReturnType,
             Awaited,
@@ -137,6 +147,7 @@ type Base = Static.Union<[
             Uncapitalize,
             Date,
             Uint8Array,
+            GenericReference,
             Reference
         ]>
     ]>
@@ -337,6 +348,15 @@ type ReturnType = Static.Tuple<[
     Type,
     Static.Const<RAngle>
 ], ReturnTypeMapping>;
+interface ArgumentMapping extends Static.IMapping {
+    output: this['input'] extends ['Argument', LAngle, infer Type extends t.TSchema, RAngle] ? Type extends t.TLiteral<infer Index extends number> ? t.TArgument<Index> : t.TNever : never;
+}
+type Argument = Static.Tuple<[
+    Static.Const<'Argument'>,
+    Static.Const<LAngle>,
+    Type,
+    Static.Const<RAngle>
+], ArgumentMapping>;
 interface AwaitedMapping extends Static.IMapping {
     output: this['input'] extends ['Awaited', LAngle, infer Type extends t.TSchema, RAngle] ? t.TAwaited<Type> : never;
 }

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

@@ -0,0 +1,9 @@
+import type { TSchema } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface TArgument<Index extends number = number> extends TSchema {
+    [Kind]: 'Argument';
+    static: unknown;
+    index: Index;
+}
+/** `[JavaScript]` Creates an Argument Type. */
+export declare function Argument<Index extends number>(index: Index): TArgument<Index>;

package/build/cjs/type/argument/argument.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Argument = Argument;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+/** `[JavaScript]` Creates an Argument Type. */
+function Argument(index) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Argument', index });
+}

package/build/cjs/type/argument/index.d.ts

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

package/build/cjs/type/argument/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./argument"), exports);

package/build/cjs/type/guard/kind.d.ts

@@ -1,14 +1,11 @@
 import { Kind, Hint, TransformKind } from '../symbols/index';
 import { TransformOptions } from '../transform/index';
-import type { TTemplateLiteral } from '../template-literal/index';
+import type { TAny } from '../any/index';
+import type { TArgument } from '../argument/index';
 import type { TArray } from '../array/index';
+import type { TAsyncIterator } from '../async-iterator/index';
 import type { TBoolean } from '../boolean/index';
 import type { TComputed } from '../computed/index';
-import type { TRecord } from '../record/index';
-import type { TString } from '../string/index';
-import type { TUnion } from '../union/index';
-import type { TAny } from '../any/index';
-import type { TAsyncIterator } from '../async-iterator/index';
 import type { TBigInt } from '../bigint/index';
 import type { TConstructor } from '../constructor/index';
 import type { TFunction } from '../function/index';
@@ -26,14 +23,18 @@ import type { TObject, TProperties } from '../object/index';
 import type { TOptional } from '../optional/index';
 import type { TPromise } from '../promise/index';
 import type { TReadonly } from '../readonly/index';
+import type { TRecord } from '../record/index';
 import type { TRef } from '../ref/index';
 import type { TRegExp } from '../regexp/index';
 import type { TSchema } from '../schema/index';
+import type { TString } from '../string/index';
 import type { TSymbol } from '../symbol/index';
+import type { TTemplateLiteral } from '../template-literal/index';
 import type { TTuple } from '../tuple/index';
 import type { TUint8Array } from '../uint8array/index';
 import type { TUndefined } from '../undefined/index';
 import type { TUnknown } from '../unknown/index';
+import type { TUnion } from '../union/index';
 import type { TUnsafe } from '../unsafe/index';
 import type { TVoid } from '../void/index';
 import type { TDate } from '../date/index';
@@ -44,6 +45,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>;
 /** `[Kind-Only]` Returns true if the given value is TAny */
 export declare function IsAny(value: unknown): value is TAny;
+/** `[Kind-Only]` Returns true if the given value is TArgument */
+export declare function IsArgument(value: unknown): value is TArgument;
 /** `[Kind-Only]` Returns true if the given value is TArray */
 export declare function IsArray(value: unknown): value is TArray;
 /** `[Kind-Only]` Returns true if the given value is TAsyncIterator */

package/build/cjs/type/guard/kind.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsReadonly = IsReadonly;
 exports.IsOptional = IsOptional;
 exports.IsAny = IsAny;
+exports.IsArgument = IsArgument;
 exports.IsArray = IsArray;
 exports.IsAsyncIterator = IsAsyncIterator;
 exports.IsBigInt = IsBigInt;
@@ -63,6 +64,10 @@ function IsOptional(value) {
 function IsAny(value) {
     return IsKindOf(value, 'Any');
 }
+/** `[Kind-Only]` Returns true if the given value is TArgument */
+function IsArgument(value) {
+    return IsKindOf(value, 'Argument');
+}
 /** `[Kind-Only]` Returns true if the given value is TArray */
 function IsArray(value) {
     return IsKindOf(value, 'Array');
@@ -243,6 +248,7 @@ function IsKind(value) {
 function IsSchema(value) {
     // prettier-ignore
     return (IsAny(value) ||
+        IsArgument(value) ||
         IsArray(value) ||
         IsBoolean(value) ||
         IsBigInt(value) ||

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

@@ -1,15 +1,12 @@
 import { Kind, Hint, TransformKind } from '../symbols/index';
 import { TypeBoxError } from '../error/index';
 import { TransformOptions } from '../transform/index';
-import type { TTemplateLiteral } from '../template-literal/index';
+import type { TAny } from '../any/index';
+import type { TArgument } from '../argument/index';
 import type { TArray } from '../array/index';
+import type { TAsyncIterator } from '../async-iterator/index';
 import type { TBoolean } from '../boolean/index';
 import type { TComputed } from '../computed/index';
-import type { TRecord } from '../record/index';
-import type { TString } from '../string/index';
-import type { TUnion } from '../union/index';
-import type { TAny } from '../any/index';
-import type { TAsyncIterator } from '../async-iterator/index';
 import type { TBigInt } from '../bigint/index';
 import type { TConstructor } from '../constructor/index';
 import type { TFunction } from '../function/index';
@@ -27,13 +24,17 @@ import type { TObject, TProperties } from '../object/index';
 import type { TOptional } from '../optional/index';
 import type { TPromise } from '../promise/index';
 import type { TReadonly } from '../readonly/index';
+import type { TRecord } from '../record/index';
 import type { TRef } from '../ref/index';
 import type { TRegExp } from '../regexp/index';
 import type { TSchema } from '../schema/index';
+import type { TString } from '../string/index';
 import type { TSymbol } from '../symbol/index';
+import type { TTemplateLiteral } from '../template-literal/index';
 import type { TTuple } from '../tuple/index';
 import type { TUint8Array } from '../uint8array/index';
 import type { TUndefined } from '../undefined/index';
+import type { TUnion } from '../union/index';
 import type { TUnknown } from '../unknown/index';
 import type { TUnsafe } from '../unsafe/index';
 import type { TVoid } from '../void/index';
@@ -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/cjs/type/guard/type.js

@@ -5,6 +5,7 @@ exports.TypeGuardUnknownTypeError = void 0;
 exports.IsReadonly = IsReadonly;
 exports.IsOptional = IsOptional;
 exports.IsAny = IsAny;
+exports.IsArgument = IsArgument;
 exports.IsArray = IsArray;
 exports.IsAsyncIterator = IsAsyncIterator;
 exports.IsBigInt = IsBigInt;
@@ -58,6 +59,7 @@ class TypeGuardUnknownTypeError extends index_2.TypeBoxError {
 }
 exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
 const KnownTypes = [
+    'Argument',
     'Any',
     'Array',
     'AsyncIterator',
@@ -157,6 +159,12 @@ function IsAny(value) {
     return (IsKindOf(value, 'Any') &&
         IsOptionalString(value.$id));
 }
+/** Returns true if the given value is TArgument */
+function IsArgument(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Argument') &&
+        ValueGuard.IsNumber(value.index));
+}
 /** Returns true if the given value is TArray */
 function IsArray(value) {
     return (IsKindOf(value, 'Array') &&
@@ -517,6 +525,7 @@ function IsKind(value) {
 function IsSchema(value) {
     // prettier-ignore
     return (ValueGuard.IsObject(value)) && (IsAny(value) ||
+        IsArgument(value) ||
         IsArray(value) ||
         IsBoolean(value) ||
         IsBigInt(value) ||

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

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

package/build/cjs/type/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./any/index"), exports);
+__exportStar(require("./argument/index"), exports);
 __exportStar(require("./array/index"), exports);
 __exportStar(require("./async-iterator/index"), exports);
 __exportStar(require("./awaited/index"), exports);
@@ -38,6 +39,7 @@ __exportStar(require("./guard/index"), exports);
 __exportStar(require("./helpers/index"), exports);
 __exportStar(require("./indexed/index"), exports);
 __exportStar(require("./instance-type/index"), exports);
+__exportStar(require("./instantiate/index"), exports);
 __exportStar(require("./integer/index"), exports);
 __exportStar(require("./intersect/index"), exports);
 __exportStar(require("./intrinsic/index"), exports);

package/build/cjs/type/instantiate/index.d.ts

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

package/build/cjs/type/instantiate/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./instantiate"), exports);

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

@@ -0,0 +1,25 @@
+import type { TSchema } from '../schema/index';
+import type { TArgument } from '../argument/index';
+import { type TNever } from '../never/index';
+import { type TReadonlyOptional } from '../readonly-optional/index';
+import { type TReadonly } from '../readonly/index';
+import { type TOptional } from '../optional/index';
+import { type TRemap, type TMapping as TRemapMapping } from '../remap/index';
+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/cjs/type/instantiate/instantiate.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Instantiate = Instantiate;
+const index_1 = require("../never/index");
+const index_2 = require("../readonly-optional/index");
+const index_3 = require("../readonly/index");
+const index_4 = require("../optional/index");
+const index_5 = require("../remap/index");
+const KindGuard = require("../guard/kind");
+// prettier-ignore
+function InstantiateArgument(argument, type) {
+    const isReadonly = KindGuard.IsReadonly(argument);
+    const isOptional = KindGuard.IsOptional(argument);
+    return (isReadonly && isOptional ? (0, index_2.ReadonlyOptional)(type) :
+        isReadonly && !isOptional ? (0, index_3.Readonly)(type) :
+            !isReadonly && isOptional ? (0, index_4.Optional)(type) :
+                type);
+}
+/** `[JavaScript]` Instantiates a type with the given parameters */
+// prettier-ignore
+function Instantiate(type, args) {
+    return (0, index_5.Remap)(type, (type) => {
+        return KindGuard.IsArgument(type)
+            ? type.index in args
+                ? KindGuard.IsSchema(args[type.index])
+                    ? InstantiateArgument(type, args[type.index])
+                    : (0, index_1.Never)()
+                : (0, index_1.Never)()
+            : type;
+    });
+}

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

@@ -3,6 +3,7 @@ import type { TSchema } from '../schema/index';
 import type { Static } from '../static/index';
 import type { Evaluate, Ensure, Assert } from '../helpers/index';
 import { type TAny } from '../any/index';
+import { type TBoolean } from '../boolean/index';
 import { type TComputed } from '../computed/index';
 import { type TEnumRecord, type TEnum } from '../enum/index';
 import { type TInteger } from '../integer/index';
@@ -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 {};