@sinclair/typebox 0.34.15 → 0.34.17

package/build/cjs/type/constructor-parameters/constructor-parameters.d.ts

@@ -1,7 +1,7 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
-import type { Ensure } from '../helpers/index';
 import type { TConstructor } from '../constructor/index';
 import { type TTuple } from '../tuple/index';
-export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = (Ensure<TTuple<T['parameters']>>);
+import { type TNever } from '../never/index';
+export type TConstructorParameters<Type extends TSchema> = (Type extends TConstructor<infer Parameters extends TSchema[], infer _InstanceType extends TSchema> ? TTuple<Parameters> : TNever);
 /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-export declare function ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
+export declare function ConstructorParameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TConstructorParameters<Type>;

package/build/cjs/type/constructor-parameters/constructor-parameters.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstructorParameters = ConstructorParameters;
 const index_1 = require("../tuple/index");
+const index_2 = require("../never/index");
+const KindGuard = require("../guard/kind");
 /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
 function ConstructorParameters(schema, options) {
-    return (0, index_1.Tuple)(schema.parameters, options);
+    return (KindGuard.IsConstructor(schema) ? (0, index_1.Tuple)(schema.parameters, options) : (0, index_2.Never)(options));
 }

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/instance-type/instance-type.d.ts

@@ -1,5 +1,6 @@
-import type { TSchema, SchemaOptions } from '../schema/index';
-import type { TConstructor } from '../constructor/index';
-export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
+import { type TSchema, SchemaOptions } from '../schema/index';
+import { type TConstructor } from '../constructor/index';
+import { type TNever } from '../never/index';
+export type TInstanceType<Type extends TSchema, Result extends TSchema = Type extends TConstructor<infer _Parameters extends TSchema[], infer InstanceType extends TSchema> ? InstanceType : TNever> = Result;
 /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-export declare function InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
+export declare function InstanceType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TInstanceType<Type>;

package/build/cjs/type/instance-type/instance-type.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstanceType = InstanceType;
 const type_1 = require("../create/type");
+const index_1 = require("../never/index");
+const KindGuard = require("../guard/kind");
 /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
 function InstanceType(schema, options) {
-    return (0, type_1.CreateType)(schema.returns, options);
+    return (KindGuard.IsConstructor(schema) ? (0, type_1.CreateType)(schema.returns, options) : (0, index_1.Never)(options));
 }

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/parameters/parameters.d.ts

@@ -1,7 +1,7 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TFunction } from '../function/index';
-import type { Ensure } from '../helpers/index';
 import { type TTuple } from '../tuple/index';
-export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>;
+import { type TNever } from '../never/index';
+export type TParameters<Type extends TSchema> = (Type extends TFunction<infer Parameters extends TSchema[], infer _ReturnType extends TSchema> ? TTuple<Parameters> : TNever);
 /** `[JavaScript]` Extracts the Parameters from the given Function type */
-export declare function Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;
+export declare function Parameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TParameters<Type>;

package/build/cjs/type/parameters/parameters.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parameters = Parameters;
 const index_1 = require("../tuple/index");
+const index_2 = require("../never/index");
+const KindGuard = require("../guard/kind");
 /** `[JavaScript]` Extracts the Parameters from the given Function type */
 function Parameters(schema, options) {
-    return (0, index_1.Tuple)(schema.parameters, options);
+    return (KindGuard.IsFunction(schema) ? (0, index_1.Tuple)(schema.parameters, options) : (0, index_2.Never)());
 }

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 {};

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

@@ -2,16 +2,21 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Record = Record;
+exports.RecordPattern = RecordPattern;
+exports.RecordKey = RecordKey;
+exports.RecordValue = RecordValue;
 const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 const index_2 = require("../computed/index");
 const index_3 = require("../never/index");
-const index_4 = require("../object/index");
-const index_5 = require("../ref/index");
-const index_6 = require("../union/index");
-const index_7 = require("../template-literal/index");
-const index_8 = require("../patterns/index");
-const index_9 = require("../indexed/index");
+const index_4 = require("../number/index");
+const index_5 = require("../object/index");
+const index_6 = require("../ref/index");
+const index_7 = require("../string/index");
+const index_8 = require("../union/index");
+const index_9 = require("../template-literal/index");
+const index_10 = require("../patterns/index");
+const index_11 = require("../indexed/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -35,17 +40,17 @@ function RecordCreateFromKeys(K, T, options) {
     const result = {};
     for (const K2 of K)
         result[K2] = T;
-    return (0, index_4.Object)(result, { ...options, [index_1.Hint]: 'Record' });
+    return (0, index_5.Object)(result, { ...options, [index_1.Hint]: 'Record' });
 }
 // prettier-ignore
 function FromTemplateLiteralKey(K, T, options) {
-    return ((0, index_7.IsTemplateLiteralFinite)(K)
-        ? RecordCreateFromKeys((0, index_9.IndexPropertyKeys)(K), T, options)
+    return ((0, index_9.IsTemplateLiteralFinite)(K)
+        ? RecordCreateFromKeys((0, index_11.IndexPropertyKeys)(K), T, options)
         : RecordCreateFromPattern(K.pattern, T, options));
 }
 // prettier-ignore
 function FromUnionKey(key, type, options) {
-    return RecordCreateFromKeys((0, index_9.IndexPropertyKeys)((0, index_6.Union)(key)), type, options);
+    return RecordCreateFromKeys((0, index_11.IndexPropertyKeys)((0, index_8.Union)(key)), type, options);
 }
 // prettier-ignore
 function FromLiteralKey(key, type, options) {
@@ -57,24 +62,28 @@ function FromRegExpKey(key, type, options) {
 }
 // prettier-ignore
 function FromStringKey(key, type, options) {
-    const pattern = (0, value_1.IsUndefined)(key.pattern) ? index_8.PatternStringExact : key.pattern;
+    const pattern = (0, value_1.IsUndefined)(key.pattern) ? index_10.PatternStringExact : key.pattern;
     return RecordCreateFromPattern(pattern, type, options);
 }
 // prettier-ignore
 function FromAnyKey(_, type, options) {
-    return RecordCreateFromPattern(index_8.PatternStringExact, type, options);
+    return RecordCreateFromPattern(index_10.PatternStringExact, type, options);
 }
 // prettier-ignore
 function FromNeverKey(_key, type, options) {
-    return RecordCreateFromPattern(index_8.PatternNeverExact, type, options);
+    return RecordCreateFromPattern(index_10.PatternNeverExact, type, options);
+}
+// prettier-ignore
+function FromBooleanKey(_key, type, options) {
+    return (0, index_5.Object)({ true: type, false: type }, options);
 }
 // prettier-ignore
 function FromIntegerKey(_key, type, options) {
-    return RecordCreateFromPattern(index_8.PatternNumberExact, type, options);
+    return RecordCreateFromPattern(index_10.PatternNumberExact, type, options);
 }
 // prettier-ignore
 function FromNumberKey(_, type, options) {
-    return RecordCreateFromPattern(index_8.PatternNumberExact, type, options);
+    return RecordCreateFromPattern(index_10.PatternNumberExact, type, options);
 }
 // ------------------------------------------------------------------
 // TRecordOrObject
@@ -84,15 +93,36 @@ function Record(key, type, options = {}) {
     // prettier-ignore
     return ((0, kind_1.IsComputed)(type) ? (0, index_2.Computed)('Record', [key, (0, index_2.Computed)(type.target, type.parameters)], options) :
         (0, kind_1.IsComputed)(key) ? (0, index_2.Computed)('Record', [(0, index_2.Computed)(type.target, type.parameters), type], options) :
-            (0, kind_1.IsRef)(key) ? (0, index_2.Computed)('Record', [(0, index_5.Ref)(key.$ref), type]) :
+            (0, kind_1.IsRef)(key) ? (0, index_2.Computed)('Record', [(0, index_6.Ref)(key.$ref), 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));
+                            (0, kind_1.IsBoolean)(key) ? FromBooleanKey(key, 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));
+}
+// ------------------------------------------------------------------
+// Record Utilities
+// ------------------------------------------------------------------
+/** Gets the Records Pattern */
+function RecordPattern(record) {
+    return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
+}
+/** Gets the Records Key Type */
+// prettier-ignore
+function RecordKey(type) {
+    const pattern = RecordPattern(type);
+    return (pattern === index_10.PatternStringExact ? (0, index_7.String)() :
+        pattern === index_10.PatternNumberExact ? (0, index_4.Number)() :
+            (0, index_7.String)({ pattern }));
+}
+/** Gets a Record Value Type */
+// prettier-ignore
+function RecordValue(type) {
+    return type.patternProperties[RecordPattern(type)];
 }

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

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

package/build/cjs/type/remap/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("./remap"), exports);

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

@@ -0,0 +1,19 @@
+import * as t from '@sinclair/typebox';
+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/cjs/type/remap/remap.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Remap = Remap;
+const t = require("@sinclair/typebox");
+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
+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/cjs/type/return-type/return-type.d.ts

@@ -1,5 +1,6 @@
-import type { SchemaOptions } from '../schema/index';
-import type { TFunction } from '../function/index';
-export type TReturnType<T extends TFunction> = T['returns'];
+import { type TSchema, type SchemaOptions } from '../schema/index';
+import { type TFunction } from '../function/index';
+import { type TNever } from '../never/index';
+export type TReturnType<Type extends TSchema, Result extends TSchema = Type extends TFunction<infer _Parameters extends TSchema[], infer ReturnType extends TSchema> ? ReturnType : TNever> = Result;
 /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-export declare function ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
+export declare function ReturnType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TReturnType<Type>;

package/build/cjs/type/return-type/return-type.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReturnType = ReturnType;
 const type_1 = require("../create/type");
+const index_1 = require("../never/index");
+const KindGuard = require("../guard/kind");
 /** `[JavaScript]` Extracts the ReturnType from the given Function type */
 function ReturnType(schema, options) {
-    return (0, type_1.CreateType)(schema.returns, options);
+    return (KindGuard.IsFunction(schema) ? (0, type_1.CreateType)(schema.returns, options) : (0, index_1.Never)(options));
 }