@sinclair/typebox 0.32.0-dev-11 → 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/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/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]) }

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]) }

package/build/require/compiler/compiler.js

@@ -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();

package/build/require/index.d.ts

@@ -21,15 +21,15 @@ export { Extends, type TExtends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCh
 export { Extract, type TExtract } from './type/extract/index';
 export { Function, type TFunction } from './type/function/index';
 export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index';
-export { Index, type TIndex, IndexedKeyResolve, IndexedTypeResolve } from './type/indexed/index';
+export { Index, type TIndex, type TMappedIndex, IndexedPropertyKeys, IndexedType, MappedIndex } from './type/indexed/index';
 export { InstanceType, type TInstanceType } from './type/instance-type/index';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index';
 export { Intersect, type TIntersect, type IntersectOptions } from './type/intersect/index';
 export { Iterator, type TIterator } from './type/iterator/index';
 export { Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase, IntrinsicResolve } from './type/intrinsic/index';
-export { KeyOf, type TKeyOf, KeyOfStringResolve, KeyOfStringResolvePattern, KeyOfTypeResolve } from './type/keyof/index';
+export { KeyOf, type TKeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index';
 export { Literal, type TLiteral } from './type/literal/index';
-export { Mapped, type TMappedKey, type MappedFunction, type TMappedResult } from './type/mapped/index';
+export { Mapped, type MappedKey as TMappedKey, type MappedFunction, type TMapped as TMappedResult } from './type/mapped/index';
 export { Never, type TNever } from './type/never/index';
 export { Not, type TNot } from './type/not/index';
 export { Null, type TNull } from './type/null/index';

package/build/require/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntrinsicResolve = exports.Uppercase = exports.Uncapitalize = exports.Lowercase = exports.Capitalize = exports.Iterator = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexedTypeResolve = exports.IndexedKeyResolve = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
-exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = exports.Unsafe = exports.Unknown = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.Readonly = exports.Promise = exports.Pick = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.Mapped = exports.Literal = exports.KeyOfTypeResolve = exports.KeyOfStringResolvePattern = exports.KeyOfStringResolve = exports.KeyOf = void 0;
+exports.Uppercase = exports.Uncapitalize = exports.Lowercase = exports.Capitalize = exports.Iterator = exports.Intersect = exports.Integer = exports.InstanceType = exports.MappedIndex = exports.IndexedType = exports.IndexedPropertyKeys = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
+exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = exports.Unsafe = exports.Unknown = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.Readonly = exports.Promise = exports.Pick = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = exports.IntrinsicResolve = void 0;
 var index_1 = require("./type/symbols/index");
 Object.defineProperty(exports, "Kind", { enumerable: true, get: function () { return index_1.Kind; } });
 Object.defineProperty(exports, "Hint", { enumerable: true, get: function () { return index_1.Hint; } });
@@ -65,8 +65,9 @@ var index_22 = require("./type/helpers/index");
 Object.defineProperty(exports, "Increment", { enumerable: true, get: function () { return index_22.Increment; } });
 var index_23 = require("./type/indexed/index");
 Object.defineProperty(exports, "Index", { enumerable: true, get: function () { return index_23.Index; } });
-Object.defineProperty(exports, "IndexedKeyResolve", { enumerable: true, get: function () { return index_23.IndexedKeyResolve; } });
-Object.defineProperty(exports, "IndexedTypeResolve", { enumerable: true, get: function () { return index_23.IndexedTypeResolve; } });
+Object.defineProperty(exports, "IndexedPropertyKeys", { enumerable: true, get: function () { return index_23.IndexedPropertyKeys; } });
+Object.defineProperty(exports, "IndexedType", { enumerable: true, get: function () { return index_23.IndexedType; } });
+Object.defineProperty(exports, "MappedIndex", { enumerable: true, get: function () { return index_23.MappedIndex; } });
 var index_24 = require("./type/instance-type/index");
 Object.defineProperty(exports, "InstanceType", { enumerable: true, get: function () { return index_24.InstanceType; } });
 var index_25 = require("./type/integer/index");
@@ -83,9 +84,8 @@ Object.defineProperty(exports, "Uppercase", { enumerable: true, get: function ()
 Object.defineProperty(exports, "IntrinsicResolve", { enumerable: true, get: function () { return index_28.IntrinsicResolve; } });
 var index_29 = require("./type/keyof/index");
 Object.defineProperty(exports, "KeyOf", { enumerable: true, get: function () { return index_29.KeyOf; } });
-Object.defineProperty(exports, "KeyOfStringResolve", { enumerable: true, get: function () { return index_29.KeyOfStringResolve; } });
-Object.defineProperty(exports, "KeyOfStringResolvePattern", { enumerable: true, get: function () { return index_29.KeyOfStringResolvePattern; } });
-Object.defineProperty(exports, "KeyOfTypeResolve", { enumerable: true, get: function () { return index_29.KeyOfTypeResolve; } });
+Object.defineProperty(exports, "KeyOfPropertyKeys", { enumerable: true, get: function () { return index_29.KeyOfPropertyKeys; } });
+Object.defineProperty(exports, "KeyOfPattern", { enumerable: true, get: function () { return index_29.KeyOfPattern; } });
 var index_30 = require("./type/literal/index");
 Object.defineProperty(exports, "Literal", { enumerable: true, get: function () { return index_30.Literal; } });
 var index_31 = require("./type/mapped/index");

package/build/require/type/composite/composite.d.ts

@@ -1,10 +1,10 @@
 import type { UnionToTuple, Assert, Evaluate } from '../helpers/index';
 import { type TObject, type ObjectOptions } from '../object/index';
 import { type TIntersect } from '../intersect/index';
-import { IndexedTypeResolve } from '../indexed/index';
+import { IndexedType } from '../indexed/index';
 type CompositeKeys<T extends TObject[]> = T extends [infer L extends TObject, ...infer R extends TObject[]] ? keyof L['properties'] | CompositeKeys<R> : never;
 type CompositeIndex<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L extends string, ...infer R extends string[]] ? {
-    [_ in L]: IndexedTypeResolve<T, [L]>;
+    [_ in L]: IndexedType<T, [L]>;
 } & CompositeIndex<T, R> : {};
 type CompositeReduce<T extends TObject[]> = UnionToTuple<CompositeKeys<T>> extends infer K ? Evaluate<CompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
 export type CompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<CompositeReduce<T>> : TObject<{}>;

package/build/require/type/composite/composite.js

@@ -8,7 +8,7 @@ const index_4 = require("../indexed/index");
 const type_1 = require("../clone/type");
 function CompositeResolve(T) {
     const intersect = (0, index_2.Intersect)(T, {});
-    const keys = (0, index_3.KeyOfStringResolve)(intersect);
+    const keys = (0, index_3.KeyOfPropertyKeys)(intersect);
     const properties = keys.reduce((acc, key) => ({ ...acc, [key]: (0, index_4.Index)(intersect, [key]) }), {});
     return (0, index_1.Object)(properties);
 }

package/build/require/type/extends/extends-mapped-result.d.ts

@@ -0,0 +1,13 @@
+import type { TSchema } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TExtends } from './extends';
+type MappedResultExtendsPropertyKeys<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema> = ({
+    [K2 in keyof K]: TExtends<K[K2], U, L, R>;
+});
+declare function MappedResultExtendsPropertyKeys<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedResultExtendsPropertyKeys<K, U, L, R>;
+type MappedResultExtendsProperties<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema> = (MappedResultExtendsPropertyKeys<K['properties'], U, L, R>);
+declare function MappedResultExtendsProperties<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedResultExtendsProperties<K, U, L, R>;
+export type MappedResultExtends<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedResultExtendsProperties<T, U, L, R>> = (TMappedResult<P>);
+export declare function MappedResultExtends<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedResultExtendsProperties<T, U, L, R>>(T: T, U: U, L: L, R: R): TMappedResult<P>;
+export {};