@sinclair/typebox 0.34.21 → 0.34.23

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

@@ -1,25 +1,50 @@
-import type { TSchema } from '../schema/index.mjs';
-import type { TArgument } from '../argument/index.mjs';
+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']);
-}
+import { type TConstructor } from '../constructor/index.mjs';
+import { type TFunction } from '../function/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
+import { type TArray } from '../array/index.mjs';
+import { type TAsyncIterator } from '../async-iterator/index.mjs';
+import { type TIterator } from '../iterator/index.mjs';
+import { type TPromise } from '../promise/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
+import { type TRecordOrObject, type TRecord } from '../record/index.mjs';
+type TFromConstructor<Args extends TSchema[], Parameters extends TSchema[], InstanceType extends TSchema, Result extends TConstructor = TConstructor<TFromTypes<Args, Parameters>, TFromType<Args, InstanceType>>> = Result;
+type TFromFunction<Args extends TSchema[], Parameters extends TSchema[], ReturnType extends TSchema, Result extends TFunction = TFunction<TFromTypes<Args, Parameters>, TFromType<Args, ReturnType>>> = Result;
+type TFromIntersect<Args extends TSchema[], Types extends TSchema[], Result extends TIntersect = TIntersect<TFromTypes<Args, Types>>> = Result;
+type TFromUnion<Args extends TSchema[], Types extends TSchema[], Result extends TUnion = TUnion<TFromTypes<Args, Types>>> = Result;
+type TFromTuple<Args extends TSchema[], Types extends TSchema[], Result extends TTuple = TTuple<TFromTypes<Args, Types>>> = Result;
+type TFromArray<Args extends TSchema[], Type extends TSchema, Result extends TArray = TArray<TFromType<Args, Type>>> = Result;
+type TFromAsyncIterator<Args extends TSchema[], Type extends TSchema, Result extends TAsyncIterator = TAsyncIterator<TFromType<Args, Type>>> = Result;
+type TFromIterator<Args extends TSchema[], Type extends TSchema, Result extends TIterator = TIterator<TFromType<Args, Type>>> = Result;
+type TFromPromise<Args extends TSchema[], Type extends TSchema, Result extends TPromise = TPromise<TFromType<Args, Type>>> = Result;
+type TFromObject<Args extends TSchema[], Properties extends TProperties, Result extends TObject = TObject<TFromProperties<Args, Properties>>> = Result;
+type TFromRecord<Args extends TSchema[], Key extends TSchema, Value extends TSchema, MappedKey extends TSchema = TFromType<Args, Key>, MappedValue extends TSchema = TFromType<Args, Value>, Result extends TSchema = TRecordOrObject<MappedKey, MappedValue>> = Result;
+type TFromArgument<Args extends TSchema[], Index extends number> = (Index extends keyof Args ? Args[Index] : TNever);
+type TFromProperty<Args extends TSchema[], Type extends TSchema, IsReadonly extends boolean = Type extends TReadonly<Type> ? true : false, IsOptional extends boolean = Type extends TOptional<Type> ? true : false, Mapped extends TSchema = TFromType<Args, Type>, Result extends TSchema = ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? TReadonlyOptional<Mapped> : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? TReadonly<Mapped> : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? TOptional<Mapped> : Mapped)> = Result;
+type TFromProperties<Args extends TSchema[], Properties extends TProperties, Result extends TProperties = {
+    [Key in keyof Properties]: TFromProperty<Args, Properties[Key]>;
+}> = Result;
+export type TFromTypes<Args extends TSchema[], Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Args, Right, [...Result, TFromType<Args, Left>]> : Result);
+export declare function FromTypes<Args extends TSchema[], Types extends TSchema[]>(args: [...Args], types: [...Types]): TFromTypes<Args, Types>;
+export type TFromType<Args extends TSchema[], Type extends TSchema> = (Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<Args, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<Args, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Args, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Args, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Args, Types> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Args, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<Args, Type> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<Args, Type> : Type extends TPromise<infer Type extends TSchema> ? TFromPromise<Args, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Args, Properties> : Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TFromRecord<Args, Key, Value> : Type extends TArgument<infer Index extends number> ? TFromArgument<Args, Index> : Type);
 /** `[JavaScript]` Instantiates a type with the given parameters */
-export type TInstantiate<Type extends TSchema, Arguments extends TSchema[]> = (TRemap<Type, TInstantiateArguments<Arguments>>);
+export type TInstantiate<Type extends TSchema, Args extends TSchema[], Result extends TSchema = TFromType<Args, Type>> = Result;
 /** `[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 declare function Instantiate<Type extends TSchema, Args extends TSchema[]>(type: Type, args: [...Args]): TInstantiate<Type, Args>;
 export {};

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

@@ -1,28 +1,114 @@
+import { CloneType } from '../clone/type.mjs';
 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 { Record, RecordKey, RecordValue } from '../record/index.mjs';
+import * as ValueGuard from '../guard/value.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);
+function FromConstructor(args, type) {
+    type.parameters = FromTypes(args, type.parameters);
+    type.returns = FromType(args, type.returns);
+    return type;
+}
+// prettier-ignore
+function FromFunction(args, type) {
+    type.parameters = FromTypes(args, type.parameters);
+    type.returns = FromType(args, type.returns);
+    return type;
+}
+// prettier-ignore
+function FromIntersect(args, type) {
+    type.allOf = FromTypes(args, type.allOf);
+    return type;
+}
+// prettier-ignore
+function FromUnion(args, type) {
+    type.anyOf = FromTypes(args, type.anyOf);
+    return type;
+}
+// prettier-ignore
+function FromTuple(args, type) {
+    if (ValueGuard.IsUndefined(type.items))
+        return type;
+    type.items = FromTypes(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromArray(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromAsyncIterator(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromIterator(args, type) {
+    type.items = FromType(args, type.items);
+    return type;
+}
+// prettier-ignore
+function FromPromise(args, type) {
+    type.item = FromType(args, type.item);
+    return type;
+}
+// prettier-ignore
+function FromObject(args, type) {
+    type.properties = FromProperties(args, type.properties);
+    return type;
+}
+// prettier-ignore
+function FromRecord(args, type) {
+    const mappedKey = FromType(args, RecordKey(type));
+    const mappedValue = FromType(args, RecordValue(type));
+    const result = Record(mappedKey, mappedValue);
+    return { ...type, ...result }; // retain options
+}
+// prettier-ignore
+function FromArgument(args, argument) {
+    return argument.index in args ? args[argument.index] : Never();
+}
+// prettier-ignore
+function FromProperty(args, type) {
+    const isReadonly = KindGuard.IsReadonly(type);
+    const isOptional = KindGuard.IsOptional(type);
+    const mapped = FromType(args, type);
+    return (isReadonly && isOptional ? ReadonlyOptional(mapped) :
+        isReadonly && !isOptional ? Readonly(mapped) :
+            !isReadonly && isOptional ? Optional(mapped) :
+                mapped);
+}
+// prettier-ignore
+function FromProperties(args, properties) {
+    return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+        return { ...result, [key]: FromProperty(args, properties[key]) };
+    }, {});
+}
+// prettier-ignore
+export function FromTypes(args, types) {
+    return types.map(type => FromType(args, type));
+}
+// prettier-ignore
+function FromType(args, type) {
+    return (KindGuard.IsConstructor(type) ? FromConstructor(args, type) :
+        KindGuard.IsFunction(type) ? FromFunction(args, type) :
+            KindGuard.IsIntersect(type) ? FromIntersect(args, type) :
+                KindGuard.IsUnion(type) ? FromUnion(args, type) :
+                    KindGuard.IsTuple(type) ? FromTuple(args, type) :
+                        KindGuard.IsArray(type) ? FromArray(args, type) :
+                            KindGuard.IsAsyncIterator(type) ? FromAsyncIterator(args, type) :
+                                KindGuard.IsIterator(type) ? FromIterator(args, type) :
+                                    KindGuard.IsPromise(type) ? FromPromise(args, type) :
+                                        KindGuard.IsObject(type) ? FromObject(args, type) :
+                                            KindGuard.IsRecord(type) ? FromRecord(args, type) :
+                                                KindGuard.IsArgument(type) ? FromArgument(args, 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;
-    });
+    return FromType(args, CloneType(type));
 }

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

@@ -10,6 +10,15 @@ import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TRef } from '../ref/index.mjs';
+import { type TBigInt } from '../bigint/index.mjs';
+import { type TBoolean } from '../boolean/index.mjs';
+import { type TInteger } from '../integer/index.mjs';
+import { type TLiteral } from '../literal/index.mjs';
+import { type TNull } from '../null/index.mjs';
+import { type TNumber } from '../number/index.mjs';
+import { type TString } from '../string/index.mjs';
+import { type TSymbol } from '../symbol/index.mjs';
+import { type TUndefined } from '../undefined/index.mjs';
 import { type TPartialFromMappedResult } from './partial-from-mapped-result.mjs';
 type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<'Partial', [TComputed<Target, Parameters>]>>;
 type TFromRef<Ref extends string> = Ensure<TComputed<'Partial', [TRef<Ref>]>>;
@@ -18,7 +27,7 @@ type TFromProperties<Properties extends TProperties> = Evaluate<{
 }>;
 type TFromObject<Type extends TObject, Properties extends TProperties = Type['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
 type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Result, TPartial<L>]> : Result);
-export type TPartial<T extends TSchema> = (T extends TRecursive<infer Type extends TSchema> ? TRecursive<TPartial<Type>> : T extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : T extends TRef<infer Ref extends string> ? TFromRef<Ref> : T extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> : T extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> : T extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> : TObject<{}>);
+export type TPartial<Type extends TSchema> = (Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TPartial<Type>> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> : Type extends TBigInt ? Type : Type extends TBoolean ? Type : Type extends TInteger ? Type : Type extends TLiteral ? Type : Type extends TNull ? Type : Type extends TNumber ? Type : Type extends TString ? Type : Type extends TSymbol ? Type : Type extends TUndefined ? Type : TObject<{}>);
 /** `[Json]` Constructs a type where all properties are optional */
 export declare function Partial<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>;
 /** `[Json]` Constructs a type where all properties are optional */

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

@@ -9,9 +9,9 @@ import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { PartialFromMappedResult } from './partial-from-mapped-result.mjs';
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject, IsRef, IsComputed } from '../guard/kind.mjs';
+import * as KindGuard from '../guard/kind.mjs';
 // prettier-ignore
 function FromComputed(target, parameters) {
     return Computed('Partial', [Computed(target, parameters)]);
@@ -28,9 +28,9 @@ function FromProperties(properties) {
     return partialProperties;
 }
 // prettier-ignore
-function FromObject(T) {
-    const options = Discard(T, [TransformKind, '$id', 'required', 'properties']);
-    const properties = FromProperties(T['properties']);
+function FromObject(type) {
+    const options = Discard(type, [TransformKind, '$id', 'required', 'properties']);
+    const properties = FromProperties(type['properties']);
     return Object(properties, options);
 }
 // prettier-ignore
@@ -42,16 +42,29 @@ function FromRest(types) {
 // ------------------------------------------------------------------
 // prettier-ignore
 function PartialResolve(type) {
-    return (IsComputed(type) ? FromComputed(type.target, type.parameters) :
-        IsRef(type) ? FromRef(type.$ref) :
-            IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
-                IsUnion(type) ? Union(FromRest(type.anyOf)) :
-                    IsObject(type) ? FromObject(type) :
-                        Object({}));
+    return (
+    // Mappable
+    KindGuard.IsComputed(type) ? FromComputed(type.target, type.parameters) :
+        KindGuard.IsRef(type) ? FromRef(type.$ref) :
+            KindGuard.IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
+                KindGuard.IsUnion(type) ? Union(FromRest(type.anyOf)) :
+                    KindGuard.IsObject(type) ? FromObject(type) :
+                        // Intrinsic
+                        KindGuard.IsBigInt(type) ? type :
+                            KindGuard.IsBoolean(type) ? type :
+                                KindGuard.IsInteger(type) ? type :
+                                    KindGuard.IsLiteral(type) ? type :
+                                        KindGuard.IsNull(type) ? type :
+                                            KindGuard.IsNumber(type) ? type :
+                                                KindGuard.IsString(type) ? type :
+                                                    KindGuard.IsSymbol(type) ? type :
+                                                        KindGuard.IsUndefined(type) ? type :
+                                                            // Passthrough
+                                                            Object({}));
 }
 /** `[Json]` Constructs a type where all properties are optional */
 export function Partial(type, options) {
-    if (IsMappedResult(type)) {
+    if (KindGuard.IsMappedResult(type)) {
         return PartialFromMappedResult(type, options);
     }
     else {

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

@@ -10,6 +10,15 @@ import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TRef } from '../ref/index.mjs';
+import { type TBigInt } from '../bigint/index.mjs';
+import { type TBoolean } from '../boolean/index.mjs';
+import { type TInteger } from '../integer/index.mjs';
+import { type TLiteral } from '../literal/index.mjs';
+import { type TNull } from '../null/index.mjs';
+import { type TNumber } from '../number/index.mjs';
+import { type TString } from '../string/index.mjs';
+import { type TSymbol } from '../symbol/index.mjs';
+import { type TUndefined } from '../undefined/index.mjs';
 import { type TRequiredFromMappedResult } from './required-from-mapped-result.mjs';
 type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<'Required', [TComputed<Target, Parameters>]>>;
 type TFromRef<Ref extends string> = Ensure<TComputed<'Required', [TRef<Ref>]>>;
@@ -18,7 +27,7 @@ type TFromProperties<Properties extends TProperties> = Evaluate<{
 }>;
 type TFromObject<Type extends TObject, Properties extends TProperties = Type['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
 type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Result, TRequired<L>]> : Result);
-export type TRequired<Type extends TSchema> = (Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TRequired<Type>> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> : TObject<{}>);
+export type TRequired<Type extends TSchema> = (Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TRequired<Type>> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> : Type extends TBigInt ? Type : Type extends TBoolean ? Type : Type extends TInteger ? Type : Type extends TLiteral ? Type : Type extends TNull ? Type : Type extends TNumber ? Type : Type extends TString ? Type : Type extends TSymbol ? Type : Type extends TUndefined ? Type : TObject<{}>);
 /** `[Json]` Constructs a type where all properties are required */
 export declare function Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>;
 /** `[Json]` Constructs a type where all properties are required */

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

@@ -10,7 +10,7 @@ import { RequiredFromMappedResult } from './required-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject, IsRef, IsComputed } from '../guard/kind.mjs';
+import * as KindGuard from '../guard/kind.mjs';
 // prettier-ignore
 function FromComputed(target, parameters) {
     return Computed('Required', [Computed(target, parameters)]);
@@ -41,16 +41,29 @@ function FromRest(types) {
 // ------------------------------------------------------------------
 // prettier-ignore
 function RequiredResolve(type) {
-    return (IsComputed(type) ? FromComputed(type.target, type.parameters) :
-        IsRef(type) ? FromRef(type.$ref) :
-            IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
-                IsUnion(type) ? Union(FromRest(type.anyOf)) :
-                    IsObject(type) ? FromObject(type) :
-                        Object({}));
+    return (
+    // Mappable
+    KindGuard.IsComputed(type) ? FromComputed(type.target, type.parameters) :
+        KindGuard.IsRef(type) ? FromRef(type.$ref) :
+            KindGuard.IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
+                KindGuard.IsUnion(type) ? Union(FromRest(type.anyOf)) :
+                    KindGuard.IsObject(type) ? FromObject(type) :
+                        // Intrinsic
+                        KindGuard.IsBigInt(type) ? type :
+                            KindGuard.IsBoolean(type) ? type :
+                                KindGuard.IsInteger(type) ? type :
+                                    KindGuard.IsLiteral(type) ? type :
+                                        KindGuard.IsNull(type) ? type :
+                                            KindGuard.IsNumber(type) ? type :
+                                                KindGuard.IsString(type) ? type :
+                                                    KindGuard.IsSymbol(type) ? type :
+                                                        KindGuard.IsUndefined(type) ? type :
+                                                            // Passthrough
+                                                            Object({}));
 }
 /** `[Json]` Constructs a type where all properties are required */
 export function Required(type, options) {
-    if (IsMappedResult(type)) {
+    if (KindGuard.IsMappedResult(type)) {
         return RequiredFromMappedResult(type, options);
     }
     else {

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

@@ -43,7 +43,6 @@ 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

@@ -46,7 +46,6 @@ 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/package.json

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

package/readme.md

@@ -64,7 +64,6 @@ License MIT
 - [Types](#types)
   - [Json](#types-json)
   - [JavaScript](#types-javascript)
-  - [Import](#types-import)
   - [Options](#types-options)
   - [Properties](#types-properties)
   - [Generics](#types-generics)
@@ -97,9 +96,9 @@ License MIT
   - [Mutate](#values-mutate)
   - [Pointer](#values-pointer)
 - [Syntax](#syntax)
-  - [Type](#syntax-type)
-  - [Options](#syntax-options)
+  - [Create](#syntax-create)
   - [Parameters](#syntax-parameters)
+  - [Options](#syntax-options)
   - [Generics](#syntax-generics)
 - [TypeRegistry](#typeregistry)
   - [Type](#typeregistry-type)
@@ -107,6 +106,8 @@ License MIT
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
+- [TypeMap](#typemap)
+  - [Usage](#typemap-usage)
 - [TypeSystem](#typesystem)
   - [Policies](#typesystem-policies)
 - [Error Function](#error-function)
@@ -638,22 +639,6 @@ TypeBox provides an extended type set that can be used to create schematics for
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name='types-import'></a>
-
-### Import
-
-Import the Type namespace to bring in the full TypeBox type system. This is recommended for most users.
-
-```typescript
-import { Type, type Static } from '@sinclair/typebox'
-```
-
-You can also selectively import types. This enables modern bundlers to tree shake for unused types.
-
-```typescript
-import { Object, Number, String, Boolean, type Static } from '@sinclair/typebox'
-```
-
 <a name='types-options'></a>
 
 ### Options
@@ -741,22 +726,6 @@ const Nullable = <T extends TSchema>(T: T) => {     // type Nullable<T> = T | nu
 const T = Nullable(Type.String())                  // type T = Nullable<string>
 ```
 
-Generic types can also be created with Argument types
-
-```typescript
-const Vector = Type.Object({                        // type Vector<A_0, A_1, A_2> = {
-  x: Type.Argument(0),                              //   x: A_0,
-  y: Type.Argument(1),                              //   y: A_1,
-  z: Type.Argument(2),                              //   z: A_2
-})                                                  // }
-
-const T = Type.Instantiate(Vector, [                // type T = Vector<
-  Type.Boolean(),                                   //   boolean, 
-  Type.Number(),                                    //   number,
-  Type.String()                                     //   string
-])                                                  // >
-```
-
 <a name='types-recursive'></a>
 
 ### Recursive Types
@@ -1337,30 +1306,50 @@ ValuePointer.Set(A, '/z', 1)                         // A' = { x: 1, y: 1, z: 1
 
 ## Syntax Types
 
-TypeBox provides optional support for runtime and type level parsing from TypeScript syntax.
+TypeBox has support for parsing TypeScript syntax at runtime as well as statically in the type system. This feature offers a syntactical frontend to the TypeBox type builder.
+
+Syntax types are available via optional import.
 
 ```typescript
 import { Syntax } from '@sinclair/typebox/syntax'
 ```
 
-<a name='syntax-type'></a>
+<a name='syntax-create'></a>
+
+### Create
+
+Use the Syntax function to create TypeBox types from TypeScript syntax
 
-### Type
+```typescript
+const T = Syntax(`{ x: number, y: number }`)        // const T: TObject<{
+                                                    //   x: TNumber,
+                                                    //   y: TNumber
+                                                    // }>
+```
+
+<a name="syntax-parameters"></a>
+
+### Parameters
 
-Use the Syntax function to create TypeBox type from TypeScript syntax.
+Syntax types can be parameterized to receive exterior types.
 
 ```typescript
 const T = Syntax(`{ x: number, y: number }`)        // const T: TObject<{
-                                                    //   x: TNumber
+                                                    //   x: TNumber,
                                                     //   y: TNumber
                                                     // }>
+
+const S = Syntax({ T }, `Partial<T>`)               // const S: TObject<{
+                                                    //   x: TOptional<TNumber>,
+                                                    //   y: TOptional<TNumber>
+                                                    // }>
 ```
 
 <a name='syntax-options'></a>
 
 ### Options
 
-Options can be passed to types on the last parameter
+Options can be passed via the last parameter
 
 ```typescript
 const T = Syntax(`number`, {                      // const T = {
@@ -1370,42 +1359,30 @@ const T = Syntax(`number`, {                      // const T = {
                                                   // }
 ```
 
-<a name="syntax-parameters"></a>
-
-### Parameters
-
-Syntax types can be parameterized to accept exterior types.
-
-```typescript
-const T = Syntax('number')
-
-const S = Syntax({ T }, `{ x: T, y: T, z: T }`)     // const S: TObject<{
-                                                    //   x: TNumber,
-                                                    //   y: TNumber,
-                                                    //   z: TNumber
-                                                    // }>
-```
-
 <a name="syntax-generics"></a>
 
 ### Generics
 
-Generic types can be created using Argument types.
+Generic types can be created using positional argument types ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgZQJ4DsYEMAecC+cAZlBCHAOQACAzsOgMYA2WwUA9DKmAKYBGEHOxoZsOCgChQkWIhTYYwBgWKly1OoxZtO3foMkSGEdDXgAVAAxwAvClG4AFBQCCUAOYBXED0wAeSwA+CgBKIxMzOHMARlt7TCdXD29fGD9o4LDjUwsAJji0BJxnNy8ff1zMiXCcuAA1HgYYaAKHYqQrABoo6O7zfPxugAMECTg4HAAuKMtOsbhUaZi58YAvJdyJfCGwmsiAISw6Ggam6BpWosckU+aoAmHR8an6xrv07tm4IJWF6dvoAFur1voFfutXmcoEDvsCwVsdtUuLw4IdjgCoBc7MgFEo-MieBAiKijsATm9zoFxtT2Ow4ASSeiKZi4k9qeyOZyudyeTzadSXkgXiDFrC4BDrIN5ryZbK5ez+eNRULpl9RSCJQ9pfKdbqFXS1tMVWLRV8IbF8Nq9da5fzCEA))
 
 ```typescript
-const Vector = Syntax(`{
-  x: Argument<0>,
-  y: Argument<1>,
-  z: Argument<2>
+const T0 = Syntax('Argument<0>')
+const T1 = Syntax('Argument<1>')
+const T2 = Syntax('Argument<2>')
+
+const Vector = Syntax({ T0, T1, T2 }, `{
+  x: T0,
+  y: T1,
+  z: T2
 }`)
 
-const Basis = Syntax({ Vector }, `{
+const BasisVectors = Syntax({ Vector }, `{
   x: Vector<1, 0, 0>,
   y: Vector<0, 1, 0>,
   z: Vector<0, 0, 1>,
 }`)
 
-type Basis = Static<typeof Basis>                   // type Basis = {
+type BasisVectors = Static<typeof BasisVectors>     // type BasisVectors = {
                                                     //   x: { x: 1, y: 0, z: 0 },
                                                     //   y: { x: 0, y: 1, z: 0 },
                                                     //   z: { x: 0, y: 0, z: 1 }
@@ -1573,6 +1550,44 @@ const C = TypeCompiler.Code(Type.String())           // const C = `return functi
                                                      // }`
 ```
 
+<a name='typemap'></a>
+
+## TypeMap
+
+TypeBox offers an external package for bi-directional mapping between TypeBox, Valibot, and Zod type libraries. It also includes syntax parsing support for Valibot and Zod and supports the Standard Schema specification. For more details on TypeMap, refer to the project repository.
+
+[TypeMap Repository](https://github.com/sinclairzx81/typemap)
+
+<a name='typemap-usage'></a>
+
+### Usage
+
+TypeMap needs to be installed seperately
+
+```bash
+$ npm install @sinclair/typemap
+```
+
+Once installed it offers advanced structural remapping between various runtime type libraries ([Example](https://www.typescriptlang.org/play/?moduleResolution=99&module=199&ts=5.8.0-beta#code/JYWwDg9gTgLgBAbzgFQJ5gKYCEIA8A0cAyqgHYwCGBcAWhACZwC+cAZlBCHAOQACAzsFIBjADYVgUAPQx0GEBTDcAUMuERS-eMjgBeFHJy4AFAAMkuAFxxSAVxAAjDFEKprdx88IAvd-adQzKYAlHBwUlJw6pra1sgA8g4AVhjCMAA8CMphObl5+QWFRcW5ETlWKABy-s4A3NkljU3NBWVhblU1UPUtvX3FbXC+nZ7dDf0TE2VMAHyq0VrEesRklCbIoS1lC-BE1twWfqOuRwE+p87MKmoaiwBKy3T0xkTBAHRgFFD8GMZ2oqJNnltrd4HdrFlJltImEKh4Aj0oU1Bh14XVxkiBjChhcxpjGtMwkA))
+
+```typescript
+import { TypeBox, Syntax, Zod } from '@sinclair/typemap'
+
+const T = TypeBox(`{ x: number, y: number, z: number }`)  // const T: TObject<{
+                                                          //   x: TNumber;
+                                                          //   y: TNumber;
+                                                          //   z: TNumber;
+                                                          // }>
+
+const S = Syntax(T)                // const S: '{ x: number, y: number, z: number }'
+
+const R = Zod(S).parse(null)       // const R: {
+                                   //   x: number;
+                                   //   y: number;
+                                   //   z: number;
+                                   // }                    
+```
+
 <a name='typesystem'></a>
 
 ## TypeSystem

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

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