@sinclair/typebox 0.32.0-dev-10 → 0.32.0-dev-12

package/build/import/type/mapped/mapped.d.mts

@@ -1,24 +1,50 @@
 import type { TSchema } from '../schema/index.mjs';
-import type { Evaluate } from '../helpers/index.mjs';
-import type { Static } from '../static/index.mjs';
-import { type TObject, type TProperties } from '../object/index.mjs';
-import { IndexedKeyResolve } from '../indexed/indexed-key.mjs';
+import type { Ensure, Evaluate } from '../helpers/index.mjs';
+import { IndexedPropertyKeys } from '../indexed/index.mjs';
 import { Kind } from '../symbols/index.mjs';
+import { type TArray } from '../array/index.mjs';
+import { type TAsyncIterator } from '../async-iterator/index.mjs';
+import { type TConstructor } from '../constructor/index.mjs';
+import { type TFunction } from '../function/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TIterator } from '../iterator/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
+import { type TPromise } from '../promise/index.mjs';
+import { type TReadonly } from '../readonly/index.mjs';
+import { type TUnion } from '../union/index.mjs';
 export interface TMappedKey<T extends PropertyKey[] = PropertyKey[]> extends TSchema {
     [Kind]: 'MappedKey';
     static: T[number];
-    anyOf: [];
+    keys: T;
 }
+export declare function MappedKey<T extends PropertyKey[]>(T: [...T]): TMappedKey<T>;
 export type MappedFunction<K extends PropertyKey[], I = TMappedKey<K>> = (T: I) => TSchema;
-export type MappedResultProperties<K extends PropertyKey[], T extends TSchema> = K extends [infer L extends string, ...infer R extends PropertyKey[]] ? {
-    [_ in `${L}`]: T;
-} & MappedResultProperties<R, T> : {};
-export type UnevaluatedMappedResult<T extends TSchema> = T;
-export type EvaluatedMappedResult<K extends PropertyKey[], T extends TSchema> = T;
-export interface TMappedResult<K extends PropertyKey[], F extends MappedFunction<K>, S extends TSchema = ReturnType<F>, R extends TSchema = EvaluatedMappedResult<K, S>, P extends TProperties = Evaluate<MappedResultProperties<K, R>>, O extends TObject = TObject<P>> extends TSchema {
+type FromMappedResult<K extends PropertyKey, P extends TProperties> = (K extends keyof P ? FromMappedPropertyKey<K, P[K]> : TNever);
+declare function FromMappedResult<K extends PropertyKey, P extends TProperties>(K: K, P: P): FromMappedResult<K, P>;
+type FromMappedKey<K extends PropertyKey, _ extends PropertyKey[]> = (K extends TLiteralValue ? TLiteral<K> : TLiteral<'never'>);
+declare function FromMappedKey<K extends PropertyKey, P extends PropertyKey[]>(K: K, _: [...P]): TLiteral<TLiteralValue>;
+type FromRest<K extends PropertyKey, T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromMappedPropertyKey<K, L>, ...FromRest<K, R>] : [];
+declare function FromRest<K extends PropertyKey, T extends TSchema[]>(K: K, T: [...T]): FromRest<K, T>;
+type FromProperties<K extends PropertyKey, T extends TProperties, R extends TProperties = Evaluate<{
+    [K2 in keyof T]: FromMappedPropertyKey<K, T[K2]>;
+}>> = R;
+declare function FromProperties<K extends PropertyKey, T extends TProperties>(K: K, T: T): FromProperties<K, T>;
+export type FromMappedPropertyKey<K extends PropertyKey, T extends TSchema> = (T extends TReadonly<infer S> ? TReadonly<FromMappedPropertyKey<K, S>> : T extends TOptional<infer S> ? TOptional<FromMappedPropertyKey<K, S>> : T extends TMappedResult<infer P> ? FromMappedResult<K, P> : T extends TMappedKey<infer S> ? FromMappedKey<K, S> : T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<FromRest<K, S>, FromMappedPropertyKey<K, R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<FromRest<K, S>, FromMappedPropertyKey<K, R>> : T extends TAsyncIterator<infer S> ? TAsyncIterator<FromMappedPropertyKey<K, S>> : T extends TIterator<infer S> ? TIterator<FromMappedPropertyKey<K, S>> : T extends TIntersect<infer S> ? TIntersect<FromRest<K, S>> : T extends TUnion<infer S> ? TUnion<FromRest<K, S>> : T extends TObject<infer S> ? TObject<FromProperties<K, S>> : T extends TArray<infer S> ? TArray<FromMappedPropertyKey<K, S>> : T extends TPromise<infer S> ? TPromise<FromMappedPropertyKey<K, S>> : T);
+export declare function FromMappedPropertyKey<K extends PropertyKey, T extends TSchema>(K: K, T: T): FromMappedPropertyKey<K, T>;
+export type FromMappedPropertyKeys<K extends PropertyKey[], T extends TSchema> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? {
+    [_ in L]: FromMappedPropertyKey<L, T>;
+} & FromMappedPropertyKeys<R, T> : {});
+export declare function FromMappedPropertyKeys<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T): FromMappedPropertyKeys<K, T>;
+export interface TMappedResult<T extends TProperties = TProperties> extends TSchema {
     [Kind]: 'MappedResult';
-    static: Static<O, this['params']>;
-    properties: P;
+    properties: T;
+    static: unknown;
 }
-export declare function Mapped<K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>, F extends MappedFunction<I> = MappedFunction<I>, R extends TMappedResult<I, F> = TMappedResult<I, F>>(key: K, map: F): R;
-export declare function Mapped<K extends PropertyKey[], F extends MappedFunction<K> = MappedFunction<K>, R extends TMappedResult<K, F> = TMappedResult<K, F>>(key: [...K], map: F): R;
+export declare function MappedResult<T extends TProperties>(properties: T): TMappedResult<T>;
+export type TMapped<K extends PropertyKey[], F extends MappedFunction<K>, R extends TProperties = Evaluate<FromMappedPropertyKeys<K, ReturnType<F>>>> = Ensure<TObject<R>>;
+export declare function Mapped<K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>, F extends MappedFunction<I> = MappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
+export declare function Mapped<K extends PropertyKey[], F extends MappedFunction<K> = MappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
+export {};

package/build/import/type/mapped/mapped.mjs

@@ -1,14 +1,78 @@
-import { Object } from '../object/index.mjs';
-import { Literal } from '../literal/index.mjs';
-import { IndexedKeyResolve } from '../indexed/indexed-key.mjs';
+import { IndexedPropertyKeys } from '../indexed/index.mjs';
 import { TSchema as IsSchemaType } from '../guard/type.mjs';
-import { Kind } from '../symbols/index.mjs';
-export function Mapped(key, map) {
-    const keys = IsSchemaType(key) ? IndexedKeyResolve(key) : key;
-    const anyOf = keys.map(key => Literal(key));
-    const mapped = { [Kind]: 'MappedKey', anyOf };
-    const properties = keys.reduce((acc, key) => {
-        return { ...acc, [key]: map(mapped) };
+import { Kind, OptionalKind, ReadonlyKind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { Discard } from '../discard/index.mjs';
+import { Array } from '../array/index.mjs';
+import { AsyncIterator } from '../async-iterator/index.mjs';
+import { Constructor } from '../constructor/index.mjs';
+import { Function as FunctionType } from '../function/index.mjs';
+import { Intersect } from '../intersect/index.mjs';
+import { Iterator } from '../iterator/index.mjs';
+import { Literal } from '../literal/index.mjs';
+import { Never } from '../never/index.mjs';
+import { Object } from '../object/index.mjs';
+import { Optional } from '../optional/index.mjs';
+import { Promise } from '../promise/index.mjs';
+import { Readonly } from '../readonly/index.mjs';
+import { Union } from '../union/index.mjs';
+import { TOptional as IsOptionalType, TReadonly as IsReadonlyType, TMappedResult as IsMappedResultType, TMappedKey as IsMappedKeyType, TConstructor as IsConstructorType, TFunction as IsFunctionType, TAsyncIterator as IsAsyncIteratorType, TIterator as IsIteratorType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TArray as IsArrayType, TPromise as IsPromiseType, } from '../guard/type.mjs';
+export function MappedKey(T) {
+    return {
+        [Kind]: 'MappedKey',
+        keys: T
+    };
+}
+function FromMappedResult(K, P) {
+    return (K in P
+        ? FromMappedPropertyKey(K, P[K])
+        : Never());
+}
+function FromMappedKey(K, _) {
+    return Literal(K);
+}
+function FromRest(K, T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [FromMappedPropertyKey(K, L), ...FromRest(K, R)]
+        : []);
+}
+function FromProperties(K, T) {
+    return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: FromMappedPropertyKey(K, T[K2]) };
     }, {});
-    return Object(properties);
+}
+export function FromMappedPropertyKey(K, T) {
+    return (IsOptionalType(T) ? Optional(FromMappedPropertyKey(K, Discard(T, [OptionalKind]))) :
+        IsReadonlyType(T) ? Readonly(FromMappedPropertyKey(K, Discard(T, [ReadonlyKind]))) :
+            IsMappedResultType(T) ? FromMappedResult(K, T.properties) :
+                IsMappedKeyType(T) ? FromMappedKey(K, T.keys) :
+                    IsConstructorType(T) ? Constructor(FromRest(K, T.parameters), FromMappedPropertyKey(K, T.returns)) :
+                        IsFunctionType(T) ? FunctionType(FromRest(K, T.parameters), FromMappedPropertyKey(K, T.returns)) :
+                            IsAsyncIteratorType(T) ? AsyncIterator(FromMappedPropertyKey(K, T.items)) :
+                                IsIteratorType(T) ? Iterator(FromMappedPropertyKey(K, T.items)) :
+                                    IsIntersectType(T) ? Intersect(FromRest(K, T.allOf)) :
+                                        IsUnionType(T) ? Union(FromRest(K, T.anyOf)) :
+                                            IsObjectType(T) ? Object(FromProperties(K, T.properties)) :
+                                                IsArrayType(T) ? Array(FromMappedPropertyKey(K, T.items)) :
+                                                    IsPromiseType(T) ? Promise(FromMappedPropertyKey(K, T.item)) :
+                                                        T);
+}
+export function FromMappedPropertyKeys(K, T) {
+    const [L, ...R] = K;
+    return (K.length > 0
+        ? { [L]: FromMappedPropertyKey(L, T), ...FromMappedPropertyKeys(R, T) }
+        : {});
+}
+export function MappedResult(properties) {
+    return {
+        [Kind]: 'MappedResult',
+        properties
+    };
+}
+export function Mapped(key, map, options = {}) {
+    const K = IsSchemaType(key) ? IndexedPropertyKeys(key) : key;
+    const RT = map({ [Kind]: 'MappedKey', keys: K });
+    const R = FromMappedPropertyKeys(K, RT);
+    return CloneType(Object(R), options);
 }

package/build/import/type/omit/omit.d.mts

@@ -4,7 +4,7 @@ import { type TRecursive } from '../recursive/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
-import { IndexedKeyResolve } from '../indexed/index.mjs';
+import { IndexedPropertyKeys } from '../indexed/index.mjs';
 type FromIntersect<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [OmitResolve<L, K>, ...FromIntersect<R, K>] : [];
 declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
 type FromUnion<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [OmitResolve<L, K>, ...FromUnion<R, K>] : [];
@@ -14,6 +14,6 @@ declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(
 export type OmitResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<OmitResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
 export declare function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): OmitResolve<T, K>;
 export type TOmit<T extends TSchema, K extends PropertyKey[]> = OmitResolve<T, K>;
-export declare function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
+export declare function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
 export declare function Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
 export {};

package/build/import/type/omit/omit.mjs

@@ -1,7 +1,7 @@
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
-import { IndexedKeyResolve } from '../indexed/index.mjs';
+import { IndexedPropertyKeys } from '../indexed/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
@@ -28,7 +28,7 @@ export function OmitResolve(T, K) {
                 Object({}));
 }
 export function Omit(T, K, options = {}) {
-    const I = IsSchemaType(K) ? IndexedKeyResolve(K) : K;
+    const I = IsSchemaType(K) ? IndexedPropertyKeys(K) : K;
     const D = Discard(T, [TransformKind, '$id', 'required']);
     const R = CloneType(OmitResolve(T, I), options);
     return { ...D, ...R };

package/build/import/type/pick/pick.d.mts

@@ -4,7 +4,7 @@ import { type TRecursive } from '../recursive/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
-import { IndexedKeyResolve } from '../indexed/index.mjs';
+import { IndexedPropertyKeys } from '../indexed/index.mjs';
 type FromIntersect<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PickResolve<L, K>, ...FromIntersect<R, K>] : [];
 declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
 type FromUnion<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PickResolve<L, K>, ...FromUnion<R, K>] : [];
@@ -14,6 +14,6 @@ declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(
 export type PickResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<PickResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
 export declare function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): PickResolve<T, K>;
 export type TPick<T extends TSchema, K extends PropertyKey[]> = PickResolve<T, K>;
-export declare function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+export declare function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
 export declare function Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
 export {};

package/build/import/type/pick/pick.mjs

@@ -1,7 +1,7 @@
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
-import { IndexedKeyResolve } from '../indexed/index.mjs';
+import { IndexedPropertyKeys } from '../indexed/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
@@ -24,7 +24,7 @@ export function PickResolve(T, K) {
                 Object({}));
 }
 export function Pick(T, K, options = {}) {
-    const I = IsSchemaType(K) ? IndexedKeyResolve(K) : K;
+    const I = IsSchemaType(K) ? IndexedPropertyKeys(K) : K;
     const D = Discard(T, [TransformKind, '$id', 'required']);
     const R = CloneType(PickResolve(T, I), options);
     return { ...D, ...R };

package/build/import/type/record/record.mjs

@@ -3,7 +3,7 @@ import { Never } from '../never/index.mjs';
 import { Union } from '../union/index.mjs';
 import { IsTemplateLiteralFinite, TemplateLiteralParseExact } from '../template-literal/index.mjs';
 import { PatternStringExact, PatternNumberExact } from '../patterns/index.mjs';
-import { IndexedKeyResolve } from '../indexed/index.mjs';
+import { IndexedPropertyKeys } from '../indexed/index.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { IsUndefined } from '../guard/value.mjs';
@@ -18,11 +18,11 @@ function FromKeys(keys, T) {
 function FromTemplateLiteralKey(K, T) {
     const expression = TemplateLiteralParseExact(K.pattern);
     return (IsTemplateLiteralFinite(expression)
-        ? FromKeys(IndexedKeyResolve(K), T)
+        ? FromKeys(IndexedPropertyKeys(K), T)
         : FromPattern(K.pattern, T));
 }
 function FromUnionKey(K, T) {
-    return FromKeys(IndexedKeyResolve(Union(K)), T);
+    return FromKeys(IndexedPropertyKeys(Union(K)), T);
 }
 function FromLiteralKey(K, T) {
     return FromKeys([K.toString()], T);

package/build/import/type/tuple/tuple.d.mts

@@ -1,7 +1,8 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Static } from '../static/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-export type TupleResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TupleResolve<R, P>] : [];
+type FromRest<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...FromRest<R, P>] : [];
+type TupleResolve<T extends TSchema[], P extends unknown[], R extends unknown[] = FromRest<T, P>> = R;
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
     static: TupleResolve<T, this['params']>;
@@ -12,3 +13,4 @@ export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     maxItems: number;
 }
 export declare function Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
+export {};

package/build/import/type/type/json.d.mts

@@ -6,17 +6,19 @@ import { type TConst } from '../const/index.mjs';
 import { type TDeref } from '../deref/index.mjs';
 import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index.mjs';
 import { type TExclude } from '../exclude/index.mjs';
-import { type TExtends } from '../extends/index.mjs';
+import { type TExtends, type MappedExtends, type MappedResultExtends } from '../extends/index.mjs';
 import { type TExtract } from '../extract/index.mjs';
-import { TIndex, type IndexedKeyResolve } from '../indexed/index.mjs';
+import { TIndex, type IndexedPropertyKeys, type TMappedIndex } from '../indexed/index.mjs';
 import { type IntegerOptions, type TInteger } from '../integer/index.mjs';
 import { type IntersectOptions, type IntersectResolve } from '../intersect/index.mjs';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index.mjs';
 import { type TKeyOf } from '../keyof/index.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
+import { type MappedFunction, type TMapped, type TMappedResult } from '../mapped/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { type TNot } from '../not/index.mjs';
 import { type TNull } from '../null/index.mjs';
+import { type TMappedKey } from '../mapped/index.mjs';
 import { type TNumber, type NumberOptions } from '../number/index.mjs';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
 import { type TOmit } from '../omit/index.mjs';
@@ -51,25 +53,30 @@ export declare class JsonTypeBuilder {
     Const<T>(value: T, options?: SchemaOptions): TConst<T>;
     Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
     Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;
-    Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options?: SchemaOptions): TExtends<L, R, T, U>;
+    Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): MappedResultExtends<L, R, T, F>;
+    Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): MappedExtends<L, R, T, F>;
+    Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
     Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
     Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
-    Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
+    Index<T extends TSchema, K extends TMappedKey>(T: T, K: K): TMappedIndex<T, K>;
+    Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
     Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;
     Integer(options?: IntegerOptions): TInteger;
     Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): IntersectResolve<T>;
     KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
     Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
     Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TLowercase<T>;
+    Mapped<K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>, F extends MappedFunction<I> = MappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
+    Mapped<K extends PropertyKey[], F extends MappedFunction<K> = MappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
     Never(options?: SchemaOptions): TNever;
     Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;
     Null(options?: SchemaOptions): TNull;
     Number(options?: NumberOptions): TNumber;
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
+    Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
     Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
     Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
-    Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+    Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
     Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
     Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordResolve<K, T>;
     Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;

package/build/import/type/type/json.mjs

@@ -14,6 +14,7 @@ import { Intersect } from '../intersect/index.mjs';
 import { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index.mjs';
 import { KeyOf } from '../keyof/index.mjs';
 import { Literal } from '../literal/index.mjs';
+import { Mapped } from '../mapped/index.mjs';
 import { Never } from '../never/index.mjs';
 import { Not } from '../not/index.mjs';
 import { Null } from '../null/index.mjs';
@@ -75,8 +76,8 @@ export class JsonTypeBuilder {
     Enum(item, options = {}) {
         return Enum(item, options);
     }
-    Extends(left, right, trueType, falseType, options = {}) {
-        return Extends(left, right, trueType, falseType, options);
+    Extends(L, R, T, F, options = {}) {
+        return Extends(L, R, T, F, options);
     }
     Exclude(unionType, excludedMembers, options = {}) {
         return Exclude(unionType, excludedMembers, options);
@@ -102,6 +103,9 @@ export class JsonTypeBuilder {
     Lowercase(schema, options = {}) {
         return Lowercase(schema, options);
     }
+    Mapped(key, map, options = {}) {
+        return Mapped(key, map, options);
+    }
     Never(options = {}) {
         return Never(options);
     }

package/build/import/value/check/check.mjs

@@ -3,7 +3,7 @@ import { TypeSystemPolicy } from '../../system/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { Hash } from '../hash/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
-import { KeyOfStringResolvePattern } from '../../type/keyof/index.mjs';
+import { KeyOfPattern } from '../../type/keyof/index.mjs';
 import { ExtendsUndefinedCheck } from '../../type/extends/index.mjs';
 import { TSchema as IsSchemaType } from '../../type/guard/type.mjs';
 import { TypeRegistry, FormatRegistry } from '../../type/registry/index.mjs';
@@ -139,12 +139,12 @@ function TInteger(schema, references, value) {
 function TIntersect(schema, references, value) {
     const check1 = schema.allOf.every((schema) => Visit(schema, references, value));
     if (schema.unevaluatedProperties === false) {
-        const keyPattern = new RegExp(KeyOfStringResolvePattern(schema));
+        const keyPattern = new RegExp(KeyOfPattern(schema));
         const check2 = Object.getOwnPropertyNames(value).every((key) => keyPattern.test(key));
         return check1 && check2;
     }
     else if (IsSchemaType(schema.unevaluatedProperties)) {
-        const keyCheck = new RegExp(KeyOfStringResolvePattern(schema));
+        const keyCheck = new RegExp(KeyOfPattern(schema));
         const check2 = Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit(schema.unevaluatedProperties, references, value[key]));
         return check1 && check2;
     }

package/build/import/value/clean/clean.mjs

@@ -1,6 +1,6 @@
 import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index.mjs';
 import { TSchema as IsSchemaType } from '../../type/guard/type.mjs';
-import { KeyOfStringResolve } from '../../type/keyof/keyof-string.mjs';
+import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { Deref } from '../deref/index.mjs';
@@ -22,7 +22,7 @@ function TIntersect(schema, references, value) {
     const composite = intersections.reduce((acc, value) => (IsObject(value) ? { ...acc, ...value } : value), {});
     if (!IsObject(value) || !IsObject(composite) || !IsSchema(unevaluatedProperties))
         return composite;
-    const knownkeys = KeyOfStringResolve(schema);
+    const knownkeys = KeyOfPropertyKeys(schema);
     for (const key of Object.getOwnPropertyNames(value)) {
         if (knownkeys.includes(key))
             continue;

package/build/import/value/index.d.mts

@@ -11,6 +11,6 @@ export { Equal } from './equal/index.mjs';
 export { Hash, ValueHashError } from './hash/index.mjs';
 export { Mutate, type Mutable, ValueMutateInvalidRootMutationError, ValueMutateTypeMismatchError } from './mutate/index.mjs';
 export { ValuePointer } from './pointer/index.mjs';
-export { Decode, Encode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
+export { TransformDecode as DecodeTransform, TransformEncode as EncodeTransform, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
 export { ArrayType, HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, ObjectType, TypedArrayType, ValueType, } from './guard/index.mjs';
 export { Value } from './value/index.mjs';

package/build/import/value/index.mjs

@@ -11,6 +11,6 @@ export { Equal } from './equal/index.mjs';
 export { Hash, ValueHashError } from './hash/index.mjs';
 export { Mutate, ValueMutateInvalidRootMutationError, ValueMutateTypeMismatchError } from './mutate/index.mjs';
 export { ValuePointer } from './pointer/index.mjs';
-export { Decode, Encode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
+export { TransformDecode as DecodeTransform, TransformEncode as EncodeTransform, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
 export { HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, } from './guard/index.mjs';
 export { Value } from './value/index.mjs';

package/build/import/value/transform/decode.d.mts

@@ -11,4 +11,4 @@ export declare class TransformDecodeError extends Error {
     readonly value: unknown;
     constructor(schema: TSchema, value: unknown, error: any);
 }
-export declare function Decode(schema: TSchema, references: TSchema[], value: unknown): unknown;
+export declare function TransformDecode(schema: TSchema, references: TSchema[], value: unknown): unknown;

package/build/import/value/transform/decode.mjs

@@ -1,8 +1,8 @@
 import { TTransform as IsTransformType, TSchema as IsSchemaType } from '../../type/guard/type.mjs';
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
 import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
-import { KeyOfStringResolve } from '../../type/keyof/index.mjs';
-import { IndexedTypeResolve } from '../../type/indexed/index.mjs';
+import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
+import { IndexedType } from '../../type/indexed/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { Check } from '../check/index.mjs';
 export class TransformDecodeCheckError extends Error {
@@ -41,10 +41,10 @@ function TArray(schema, references, value) {
 function TIntersect(schema, references, value) {
     if (!IsPlainObject(value) || IsValueType(value))
         return Default(schema, value);
-    const knownKeys = KeyOfStringResolve(schema);
+    const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
-            ? { ...value, [key]: Visit(IndexedTypeResolve(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit(IndexedType(schema, [key]), references, value[key]) }
             : value;
     }, value);
     if (!IsTransformType(schema.unevaluatedProperties)) {
@@ -65,7 +65,7 @@ function TNot(schema, references, value) {
 function TObject(schema, references, value) {
     if (!IsPlainObject(value))
         return Default(schema, value);
-    const knownKeys = KeyOfStringResolve(schema);
+    const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
             ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
@@ -155,6 +155,6 @@ function Visit(schema, references, value) {
             return Default(schema_, value);
     }
 }
-export function Decode(schema, references, value) {
+export function TransformDecode(schema, references, value) {
     return Visit(schema, references, value);
 }

package/build/import/value/transform/encode.d.mts

@@ -11,4 +11,4 @@ export declare class TransformEncodeError extends Error {
     readonly value: unknown;
     constructor(schema: TSchema, value: unknown, error: any);
 }
-export declare function Encode(schema: TSchema, references: TSchema[], value: unknown): unknown;
+export declare function TransformEncode(schema: TSchema, references: TSchema[], value: unknown): unknown;

package/build/import/value/transform/encode.mjs

@@ -1,8 +1,8 @@
 import { TTransform as IsTransformType, TSchema as IsSchemaType } from '../../type/guard/type.mjs';
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
 import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
-import { KeyOfStringResolve } from '../../type/keyof/index.mjs';
-import { IndexedTypeResolve } from '../../type/indexed/index.mjs';
+import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
+import { IndexedType } from '../../type/indexed/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { Check } from '../check/index.mjs';
 export class TransformEncodeCheckError extends Error {
@@ -43,10 +43,10 @@ function TIntersect(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!IsPlainObject(value) || IsValueType(value))
         return defaulted;
-    const knownKeys = KeyOfStringResolve(schema);
+    const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return key in defaulted
-            ? { ...value, [key]: Visit(IndexedTypeResolve(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit(IndexedType(schema, [key]), references, value[key]) }
             : value;
     }, defaulted);
     if (!IsTransformType(schema.unevaluatedProperties)) {
@@ -67,7 +67,7 @@ function TObject(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!IsPlainObject(value))
         return defaulted;
-    const knownKeys = KeyOfStringResolve(schema);
+    const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return key in value
             ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
@@ -161,6 +161,6 @@ function Visit(schema, references, value) {
             return Default(schema_, value);
     }
 }
-export function Encode(schema, references, value) {
+export function TransformEncode(schema, references, value) {
     return Visit(schema, references, value);
 }

package/build/import/value/value/value.mjs

@@ -1,4 +1,4 @@
-import { Decode as DecodeValue, Encode as EncodeValue, TransformDecodeCheckError, TransformEncodeCheckError } from '../transform/index.mjs';
+import { TransformDecode, TransformEncode, TransformDecodeCheckError, TransformEncodeCheckError } from '../transform/index.mjs';
 import { Mutate as MutateValue } from '../mutate/index.mjs';
 import { Hash as HashValue } from '../hash/index.mjs';
 import { Equal as EqualValue } from '../equal/index.mjs';
@@ -33,14 +33,14 @@ export function Decode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
     if (!Check(schema, references, value))
         throw new TransformDecodeCheckError(schema, value, Errors(schema, references, value).First());
-    return DecodeValue(schema, references, value);
+    return TransformDecode(schema, references, value);
 }
 export function Default(...args) {
     return DefaultValue.apply(DefaultValue, args);
 }
 export function Encode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
-    const encoded = EncodeValue(schema, references, value);
+    const encoded = TransformEncode(schema, references, value);
     if (!Check(schema, references, encoded))
         throw new TransformEncodeCheckError(schema, value, Errors(schema, references, value).First());
     return encoded;

package/build/require/compiler/compiler.js

@@ -33,10 +33,10 @@ class TypeCheck {
     Decode(value) {
         if (!this.checkFunc(value))
             throw new index_1.TransformDecodeCheckError(this.schema, value, this.Errors(value).First());
-        return this.hasTransform ? (0, index_1.Decode)(this.schema, this.references, value) : value;
+        return this.hasTransform ? (0, index_1.TransformDecode)(this.schema, this.references, value) : value;
     }
     Encode(value) {
-        const encoded = this.hasTransform ? (0, index_1.Encode)(this.schema, this.references, value) : value;
+        const encoded = this.hasTransform ? (0, index_1.TransformEncode)(this.schema, this.references, value) : value;
         if (!this.checkFunc(encoded))
             throw new index_1.TransformEncodeCheckError(this.schema, value, this.Errors(value).First());
         return encoded;
@@ -237,12 +237,12 @@ var TypeCompiler;
     function* TIntersect(schema, references, value) {
         const check1 = schema.allOf.map((schema) => CreateExpression(schema, references, value)).join(' && ');
         if (schema.unevaluatedProperties === false) {
-            const keyCheck = CreateVariable(`${new RegExp((0, index_9.KeyOfStringResolvePattern)(schema))};`);
+            const keyCheck = CreateVariable(`${new RegExp((0, index_9.KeyOfPattern)(schema))};`);
             const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key))`;
             yield `(${check1} && ${check2})`;
         }
         else if ((0, type_1.TSchema)(schema.unevaluatedProperties)) {
-            const keyCheck = CreateVariable(`${new RegExp((0, index_9.KeyOfStringResolvePattern)(schema))};`);
+            const keyCheck = CreateVariable(`${new RegExp((0, index_9.KeyOfPattern)(schema))};`);
             const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, `${value}[key]`)})`;
             yield `(${check1} && ${check2})`;
         }

package/build/require/errors/errors.js

@@ -227,7 +227,7 @@ function* TIntersect(schema, references, path, value) {
         }
     }
     if (schema.unevaluatedProperties === false) {
-        const keyCheck = new RegExp((0, index_3.KeyOfStringResolvePattern)(schema));
+        const keyCheck = new RegExp((0, index_3.KeyOfPattern)(schema));
         for (const valueKey of Object.getOwnPropertyNames(value)) {
             if (!keyCheck.test(valueKey)) {
                 yield Create(ValueErrorType.IntersectUnevaluatedProperties, schema, `${path}/${valueKey}`, value);
@@ -235,7 +235,7 @@ function* TIntersect(schema, references, path, value) {
         }
     }
     if (typeof schema.unevaluatedProperties === 'object') {
-        const keyCheck = new RegExp((0, index_3.KeyOfStringResolvePattern)(schema));
+        const keyCheck = new RegExp((0, index_3.KeyOfPattern)(schema));
         for (const valueKey of Object.getOwnPropertyNames(value)) {
             if (!keyCheck.test(valueKey)) {
                 const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next();