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

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

@@ -0,0 +1,7 @@
+import { Kind } from '../symbols/index.mjs';
+export function MappedResult(properties) {
+    return {
+        [Kind]: 'MappedResult',
+        properties
+    };
+}

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

@@ -1,11 +1,10 @@
 import type { TSchema } from '../schema/index.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 TIndexPropertyKeys } from '../indexed/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';
@@ -14,37 +13,28 @@ import { type TObject, type TProperties, type ObjectOptions } from '../object/in
 import { type TOptional } from '../optional/index.mjs';
 import { type TPromise } from '../promise/index.mjs';
 import { type TReadonly } from '../readonly/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
 import { type TUnion } from '../union/index.mjs';
-export interface TMappedKey<T extends PropertyKey[] = PropertyKey[]> extends TSchema {
-    [Kind]: 'MappedKey';
-    static: T[number];
-    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;
-type FromMappedResult<K extends PropertyKey, P extends TProperties> = (K extends keyof P ? FromMappedPropertyKey<K, P[K]> : TNever);
+import type { TMappedResult } from './mapped-result.mjs';
+import type { TMappedKey } from './mapped-key.mjs';
+type FromMappedResult<K extends PropertyKey, P extends TProperties> = (K extends keyof P ? FromSchemaType<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>] : [];
+type FromRest<K extends PropertyKey, T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromSchemaType<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]>;
+    [K2 in keyof T]: FromSchemaType<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';
-    properties: T;
-    static: unknown;
-}
-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;
+type FromSchemaType<K extends PropertyKey, T extends TSchema> = (T extends TReadonly<infer S> ? TReadonly<FromSchemaType<K, S>> : T extends TOptional<infer S> ? TOptional<FromSchemaType<K, S>> : T extends TMappedResult<infer P> ? FromMappedResult<K, P> : T extends TMappedKey<infer P> ? FromMappedKey<K, P> : T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<FromRest<K, S>, FromSchemaType<K, R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<FromRest<K, S>, FromSchemaType<K, R>> : T extends TAsyncIterator<infer S> ? TAsyncIterator<FromSchemaType<K, S>> : T extends TIterator<infer S> ? TIterator<FromSchemaType<K, S>> : T extends TIntersect<infer S> ? TIntersect<FromRest<K, S>> : T extends TUnion<infer S> ? TUnion<FromRest<K, S>> : T extends TTuple<infer S> ? TTuple<FromRest<K, S>> : T extends TObject<infer S> ? TObject<FromProperties<K, S>> : T extends TArray<infer S> ? TArray<FromSchemaType<K, S>> : T extends TPromise<infer S> ? TPromise<FromSchemaType<K, S>> : T);
+declare function FromSchemaType<K extends PropertyKey, T extends TSchema>(K: K, T: T): FromSchemaType<K, T>;
+type FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? {
+    [_ in L]: FromSchemaType<L, T>;
+} & FromMappedFunctionReturnType<R, T> : {});
+declare function FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T): FromMappedFunctionReturnType<K, T>;
+export type TMappedFunction<K extends PropertyKey[], I = TMappedKey<K>> = (T: I) => TSchema;
+export type TMapped<K extends PropertyKey[], F extends TMappedFunction<K>, R extends TProperties = Evaluate<FromMappedFunctionReturnType<K, ReturnType<F>>>> = Ensure<TObject<R>>;
+export declare function Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<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 TMappedFunction<K> = TMappedFunction<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,4 +1,3 @@
-import { IndexedPropertyKeys } from '../indexed/index.mjs';
 import { TSchema as IsSchemaType } from '../guard/type.mjs';
 import { Kind, OptionalKind, ReadonlyKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
@@ -7,6 +6,7 @@ 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 { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Iterator } from '../iterator/index.mjs';
 import { Literal } from '../literal/index.mjs';
@@ -15,17 +15,12 @@ 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 { Tuple } from '../tuple/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
-    };
-}
+import { TArray as IsArrayType, TAsyncIterator as IsAsyncIteratorType, TConstructor as IsConstructorType, TFunction as IsFunctionType, TIntersect as IsIntersectType, TIterator as IsIteratorType, TReadonly as IsReadonlyType, TMappedResult as IsMappedResultType, TMappedKey as IsMappedKeyType, TObject as IsObjectType, TOptional as IsOptionalType, TPromise as IsPromiseType, TTuple as IsTupleType, TUnion as IsUnionType, } from '../guard/type.mjs';
 function FromMappedResult(K, P) {
     return (K in P
-        ? FromMappedPropertyKey(K, P[K])
+        ? FromSchemaType(K, P[K])
         : Never());
 }
 function FromMappedKey(K, _) {
@@ -34,45 +29,40 @@ function FromMappedKey(K, _) {
 function FromRest(K, T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [FromMappedPropertyKey(K, L), ...FromRest(K, R)]
+        ? [FromSchemaType(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 { ...Acc, [K2]: FromSchemaType(K, T[K2]) };
     }, {});
 }
-export function FromMappedPropertyKey(K, T) {
-    return (IsOptionalType(T) ? Optional(FromMappedPropertyKey(K, Discard(T, [OptionalKind]))) :
-        IsReadonlyType(T) ? Readonly(FromMappedPropertyKey(K, Discard(T, [ReadonlyKind]))) :
+function FromSchemaType(K, T) {
+    return (IsOptionalType(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) :
+        IsReadonlyType(T) ? Readonly(FromSchemaType(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)) :
+                    IsConstructorType(T) ? Constructor(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                        IsFunctionType(T) ? FunctionType(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                            IsAsyncIteratorType(T) ? AsyncIterator(FromSchemaType(K, T.items)) :
+                                IsIteratorType(T) ? Iterator(FromSchemaType(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);
+                                            IsTupleType(T) ? Tuple(FromRest(K, T.items ?? [])) :
+                                                IsObjectType(T) ? Object(FromProperties(K, T.properties)) :
+                                                    IsArrayType(T) ? Array(FromSchemaType(K, T.items)) :
+                                                        IsPromiseType(T) ? Promise(FromSchemaType(K, T.item)) :
+                                                            T);
 }
-export function FromMappedPropertyKeys(K, T) {
+function FromMappedFunctionReturnType(K, T) {
     const [L, ...R] = K;
     return (K.length > 0
-        ? { [L]: FromMappedPropertyKey(L, T), ...FromMappedPropertyKeys(R, T) }
+        ? { [L]: FromSchemaType(L, T), ...FromMappedFunctionReturnType(R, T) }
         : {});
 }
-export function MappedResult(properties) {
-    return {
-        [Kind]: 'MappedResult',
-        properties
-    };
-}
 export function Mapped(key, map, options = {}) {
-    const K = IsSchemaType(key) ? IndexedPropertyKeys(key) : key;
+    const K = IsSchemaType(key) ? IndexPropertyKeys(key) : key;
     const RT = map({ [Kind]: 'MappedKey', keys: K });
-    const R = FromMappedPropertyKeys(K, RT);
+    const R = FromMappedFunctionReturnType(K, RT);
     return CloneType(Object(R), options);
 }

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

@@ -1 +1,2 @@
+export * from './omit-mapped-result.mjs';
 export * from './omit.mjs';

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

@@ -1 +1,2 @@
+export * from './omit-mapped-result.mjs';
 export * from './omit.mjs';

package/build/import/type/omit/omit-mapped-result.d.mts

@@ -0,0 +1,15 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { type TOmit } from './omit.mjs';
+type MappedOmitPropertyKey<T extends TSchema, K extends PropertyKey> = {
+    [_ in K]: TOmit<T, [K]>;
+};
+declare function MappedOmitPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): MappedOmitPropertyKey<T, K>;
+type MappedOmitPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? MappedOmitPropertyKey<T, LK> & MappedOmitPropertyKeys<T, RK> : {});
+declare function MappedOmitPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): MappedOmitPropertyKeys<T, K>;
+type MappedOmitProperties<T extends TSchema, K extends TMappedKey> = (MappedOmitPropertyKeys<T, K['keys']>);
+declare function MappedOmitProperties<T extends TSchema, K extends TMappedKey>(T: T, K: K): MappedOmitProperties<T, K>;
+export type TOmitMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedOmitProperties<T, K>> = (TMappedResult<P>);
+export declare function OmitMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedOmitProperties<T, K>>(T: T, K: K): TMappedResult<P>;
+export {};

package/build/import/type/omit/omit-mapped-result.mjs

@@ -0,0 +1,20 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Omit } from './omit.mjs';
+function MappedOmitPropertyKey(T, K) {
+    return {
+        [K]: Omit(T, [K])
+    };
+}
+function MappedOmitPropertyKeys(T, K) {
+    const [LK, ...RK] = K;
+    return (K.length > 0
+        ? { ...MappedOmitPropertyKey(T, LK), ...MappedOmitPropertyKeys(T, RK) }
+        : {});
+}
+function MappedOmitProperties(T, K) {
+    return MappedOmitPropertyKeys(T, K.keys);
+}
+export function OmitMappedResult(T, K) {
+    const P = MappedOmitProperties(T, K);
+    return MappedResult(P);
+}

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

@@ -4,7 +4,9 @@ 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 { IndexedPropertyKeys } from '../indexed/index.mjs';
+import { type TIndexPropertyKeys } from '../indexed/index.mjs';
+import { TMappedKey } from '../mapped/index.mjs';
+import { type TOmitMappedResult } from './omit-mapped-result.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 +16,7 @@ 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[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
+export declare function Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitMappedResult<T, K>;
+export declare function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<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,11 +1,12 @@
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
-import { IndexedPropertyKeys } from '../indexed/index.mjs';
+import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-import { TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
+import { OmitMappedResult } from './omit-mapped-result.mjs';
+import { TMappedKey as IsMappedKeyType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
 function FromIntersect(T, K) {
     return T.map((T) => OmitResolve(T, K));
 }
@@ -28,8 +29,13 @@ export function OmitResolve(T, K) {
                 Object({}));
 }
 export function Omit(T, K, options = {}) {
-    const I = IsSchemaType(K) ? IndexedPropertyKeys(K) : K;
-    const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(OmitResolve(T, I), options);
-    return { ...D, ...R };
+    if (IsMappedKeyType(K)) {
+        return OmitMappedResult(T, K);
+    }
+    else {
+        const I = IsSchemaType(K) ? IndexPropertyKeys(K) : K;
+        const D = Discard(T, [TransformKind, '$id', 'required']);
+        const R = CloneType(OmitResolve(T, I), options);
+        return { ...D, ...R };
+    }
 }

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

@@ -1 +1,2 @@
+export * from './pick-mapped-result.mjs';
 export * from './pick.mjs';

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

@@ -1 +1,2 @@
+export * from './pick-mapped-result.mjs';
 export * from './pick.mjs';

package/build/import/type/pick/pick-mapped-result.d.mts

@@ -0,0 +1,15 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { type TPick } from './pick.mjs';
+type MappedPickPropertyKey<T extends TSchema, K extends PropertyKey> = {
+    [_ in K]: TPick<T, [K]>;
+};
+declare function MappedPickPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): MappedPickPropertyKey<T, K>;
+type MappedPickPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? MappedPickPropertyKey<T, LK> & MappedPickPropertyKeys<T, RK> : {});
+declare function MappedPickPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): MappedPickPropertyKeys<T, K>;
+type MappedPickProperties<T extends TSchema, K extends TMappedKey> = (MappedPickPropertyKeys<T, K['keys']>);
+declare function MappedPickProperties<T extends TSchema, K extends TMappedKey>(T: T, K: K): MappedPickProperties<T, K>;
+export type TPickMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedPickProperties<T, K>> = (TMappedResult<P>);
+export declare function PickMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedPickProperties<T, K>>(T: T, K: K): TMappedResult<P>;
+export {};

package/build/import/type/pick/pick-mapped-result.mjs

@@ -0,0 +1,20 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Pick } from './pick.mjs';
+function MappedPickPropertyKey(T, K) {
+    return {
+        [K]: Pick(T, [K])
+    };
+}
+function MappedPickPropertyKeys(T, K) {
+    const [LK, ...RK] = K;
+    return (K.length > 0
+        ? { ...MappedPickPropertyKey(T, LK), ...MappedPickPropertyKeys(T, RK) }
+        : {});
+}
+function MappedPickProperties(T, K) {
+    return MappedPickPropertyKeys(T, K.keys);
+}
+export function PickMappedResult(T, K) {
+    const P = MappedPickProperties(T, K);
+    return MappedResult(P);
+}

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

@@ -4,7 +4,9 @@ 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 { IndexedPropertyKeys } from '../indexed/index.mjs';
+import { type TIndexPropertyKeys } from '../indexed/index.mjs';
+import { TMappedKey } from '../mapped/index.mjs';
+import { type TPickMappedResult } from './pick-mapped-result.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 +16,7 @@ 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[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+export declare function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickMappedResult<T, K>;
+export declare function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<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,11 +1,12 @@
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
-import { IndexedPropertyKeys } from '../indexed/index.mjs';
+import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-import { TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
+import { PickMappedResult } from './pick-mapped-result.mjs';
+import { TMappedKey as IsMappedKeyType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType, } from '../guard/type.mjs';
 function FromIntersect(T, K) {
     return T.map((T) => PickResolve(T, K));
 }
@@ -24,8 +25,13 @@ export function PickResolve(T, K) {
                 Object({}));
 }
 export function Pick(T, K, options = {}) {
-    const I = IsSchemaType(K) ? IndexedPropertyKeys(K) : K;
-    const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(PickResolve(T, I), options);
-    return { ...D, ...R };
+    if (IsMappedKeyType(K)) {
+        return PickMappedResult(T, K);
+    }
+    else {
+        const I = IsSchemaType(K) ? IndexPropertyKeys(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,11 +3,11 @@ 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 { IndexedPropertyKeys } from '../indexed/index.mjs';
+import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { IsUndefined } from '../guard/value.mjs';
-import { TUnion as IsUnionType, TTemplateLiteral as IsTemplateLiteralType, TLiteral as IsLiteralType, TString as IsStringType, TInteger as IsIntegerType, TNumber as IsNumberType } from '../guard/type.mjs';
+import { TInteger as IsIntegerType, TLiteral as IsLiteralType, TNumber as IsNumberType, TString as IsStringType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, } from '../guard/type.mjs';
 function FromPattern(pattern, T) {
     return { [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: CloneType(T) } };
 }
@@ -18,11 +18,11 @@ function FromKeys(keys, T) {
 function FromTemplateLiteralKey(K, T) {
     const expression = TemplateLiteralParseExact(K.pattern);
     return (IsTemplateLiteralFinite(expression)
-        ? FromKeys(IndexedPropertyKeys(K), T)
+        ? FromKeys(IndexPropertyKeys(K), T)
         : FromPattern(K.pattern, T));
 }
 function FromUnionKey(K, T) {
-    return FromKeys(IndexedPropertyKeys(Union(K)), T);
+    return FromKeys(IndexPropertyKeys(Union(K)), T);
 }
 function FromLiteralKey(K, T) {
     return FromKeys([K.toString()], T);

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

@@ -6,25 +6,25 @@ 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, type MappedExtends, type MappedResultExtends } from '../extends/index.mjs';
+import { type TExtends, type TExtendsMappedResult, type TExtendsMappedResultFromResult } from '../extends/index.mjs';
 import { type TExtract } from '../extract/index.mjs';
-import { TIndex, type IndexedPropertyKeys, type TMappedIndex } from '../indexed/index.mjs';
+import { TIndex, type TIndexPropertyKeys, type TIndexMappedResult } 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 TMappedFunction, 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';
+import { type TOmit, type TOmitMappedResult } from '../omit/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import { type TPartial } from '../partial/index.mjs';
-import { type TPick } from '../pick/index.mjs';
+import { type TPick, type TPickMappedResult } from '../pick/index.mjs';
 import { type TReadonly } from '../readonly/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type RecordResolve } from '../record/index.mjs';
@@ -53,30 +53,32 @@ 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 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 TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsMappedResultFromResult<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): TExtendsMappedResult<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 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 TMappedKey>(T: T, K: K): TIndexMappedResult<T, K>;
+    Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<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;
+    Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
+    Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<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[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
+    Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitMappedResult<T, K>;
+    Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<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[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickMappedResult<T, K>;
+    Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<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/value/transform/decode.mjs

@@ -2,7 +2,7 @@ import { TTransform as IsTransformType, TSchema as IsSchemaType } from '../../ty
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
 import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
 import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
-import { IndexedType } from '../../type/indexed/index.mjs';
+import { Index } from '../../type/indexed/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { Check } from '../check/index.mjs';
 export class TransformDecodeCheckError extends Error {
@@ -44,7 +44,7 @@ function TIntersect(schema, references, value) {
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
-            ? { ...value, [key]: Visit(IndexedType(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit(Index(schema, [key]), references, value[key]) }
             : value;
     }, value);
     if (!IsTransformType(schema.unevaluatedProperties)) {

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

@@ -2,7 +2,7 @@ import { TTransform as IsTransformType, TSchema as IsSchemaType } from '../../ty
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
 import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
 import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
-import { IndexedType } from '../../type/indexed/index.mjs';
+import { Index } from '../../type/indexed/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { Check } from '../check/index.mjs';
 export class TransformEncodeCheckError extends Error {
@@ -46,7 +46,7 @@ function TIntersect(schema, references, value) {
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return key in defaulted
-            ? { ...value, [key]: Visit(IndexedType(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit(Index(schema, [key]), references, value[key]) }
             : value;
     }, defaulted);
     if (!IsTransformType(schema.unevaluatedProperties)) {

package/build/require/index.d.ts

@@ -21,25 +21,25 @@ 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, type TMappedIndex, IndexedPropertyKeys, IndexedType, MappedIndex } from './type/indexed/index';
+export { Index, IndexPropertyKeys, IndexMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexMappedResult } 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 { Intrinsic, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index';
 export { KeyOf, type TKeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index';
 export { Literal, type TLiteral } from './type/literal/index';
-export { Mapped, type MappedKey as TMappedKey, type MappedFunction, type TMapped as TMappedResult } from './type/mapped/index';
+export { Mapped, MappedKey, MappedResult, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction } 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';
 export { Number, type TNumber, type NumberOptions } from './type/number/index';
 export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index';
-export { Omit, type TOmit } from './type/omit/index';
+export { Omit, type TOmit, type TOmitMappedResult } from './type/omit/index';
 export { Optional, type TOptional } from './type/optional/index';
 export { Parameters, type TParameters } from './type/parameters/index';
 export { Partial, type TPartial } from './type/partial/index';
-export { Pick, type TPick } from './type/pick/index';
+export { Pick, type TPick, type TPickMappedResult } from './type/pick/index';
 export { Promise, type TPromise } from './type/promise/index';
 export { Readonly, type TReadonly } from './type/readonly/index';
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index';