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

package/build/require/type/intrinsic/uncapitalize.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uncapitalize = void 0;
+const intrinsic_1 = require("./intrinsic");
+const type_1 = require("../clone/type");
+function Uncapitalize(T, options = {}) {
+    return (0, type_1.CloneType)((0, intrinsic_1.Intrinsic)(T, 'Uncapitalize'), options);
+}
+exports.Uncapitalize = Uncapitalize;

package/build/require/type/intrinsic/uppercase.d.ts

@@ -0,0 +1,4 @@
+import { TSchema, SchemaOptions } from '../schema/index';
+import { TIntrinsic } from './intrinsic';
+export type TUppercase<T extends TSchema> = TIntrinsic<T, 'Uppercase'>;
+export declare function Uppercase<T extends TSchema>(T: T, options?: SchemaOptions): TUppercase<T>;

package/build/require/type/intrinsic/uppercase.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uppercase = void 0;
+const intrinsic_1 = require("./intrinsic");
+const type_1 = require("../clone/type");
+function Uppercase(T, options = {}) {
+    return (0, type_1.CloneType)((0, intrinsic_1.Intrinsic)(T, 'Uppercase'), options);
+}
+exports.Uppercase = Uppercase;

package/build/require/type/mapped/index.d.ts

@@ -1 +1,3 @@
+export * from './mapped-key';
+export * from './mapped-result';
 export * from './mapped';

package/build/require/type/mapped/index.js

@@ -14,4 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mapped-key"), exports);
+__exportStar(require("./mapped-result"), exports);
 __exportStar(require("./mapped"), exports);

package/build/require/type/mapped/mapped-key.d.ts

@@ -0,0 +1,8 @@
+import type { TSchema } from '../schema/index';
+import { Kind } from '../symbols/index';
+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>;

package/build/require/type/mapped/mapped-key.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappedKey = void 0;
+const index_1 = require("../symbols/index");
+function MappedKey(T) {
+    return {
+        [index_1.Kind]: 'MappedKey',
+        keys: T
+    };
+}
+exports.MappedKey = MappedKey;

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

@@ -0,0 +1,9 @@
+import type { TSchema } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { Kind } from '../symbols/index';
+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>;

package/build/require/type/mapped/mapped-result.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappedResult = void 0;
+const index_1 = require("../symbols/index");
+function MappedResult(properties) {
+    return {
+        [index_1.Kind]: 'MappedResult',
+        properties
+    };
+}
+exports.MappedResult = MappedResult;

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

@@ -1,11 +1,10 @@
 import type { TSchema } from '../schema/index';
 import type { Ensure, Evaluate } from '../helpers/index';
-import { IndexedPropertyKeys } from '../indexed/index';
-import { Kind } from '../symbols/index';
 import { type TArray } from '../array/index';
 import { type TAsyncIterator } from '../async-iterator/index';
 import { type TConstructor } from '../constructor/index';
 import { type TFunction } from '../function/index';
+import { type TIndexPropertyKeys } from '../indexed/index';
 import { type TIntersect } from '../intersect/index';
 import { type TIterator } from '../iterator/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
@@ -14,37 +13,28 @@ import { type TObject, type TProperties, type ObjectOptions } from '../object/in
 import { type TOptional } from '../optional/index';
 import { type TPromise } from '../promise/index';
 import { type TReadonly } from '../readonly/index';
+import { type TTuple } from '../tuple/index';
 import { type TUnion } from '../union/index';
-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';
+import type { TMappedKey } from './mapped-key';
+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/require/type/mapped/mapped.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Mapped = exports.MappedResult = exports.FromMappedPropertyKeys = exports.FromMappedPropertyKey = exports.MappedKey = void 0;
-const index_1 = require("../indexed/index");
+exports.Mapped = void 0;
 const type_1 = require("../guard/type");
-const index_2 = require("../symbols/index");
+const index_1 = require("../symbols/index");
 const type_2 = require("../clone/type");
-const index_3 = require("../discard/index");
-const index_4 = require("../array/index");
-const index_5 = require("../async-iterator/index");
-const index_6 = require("../constructor/index");
-const index_7 = require("../function/index");
+const index_2 = require("../discard/index");
+const index_3 = require("../array/index");
+const index_4 = require("../async-iterator/index");
+const index_5 = require("../constructor/index");
+const index_6 = require("../function/index");
+const index_7 = require("../indexed/index");
 const index_8 = require("../intersect/index");
 const index_9 = require("../iterator/index");
 const index_10 = require("../literal/index");
@@ -18,18 +18,12 @@ const index_12 = require("../object/index");
 const index_13 = require("../optional/index");
 const index_14 = require("../promise/index");
 const index_15 = require("../readonly/index");
-const index_16 = require("../union/index");
+const index_16 = require("../tuple/index");
+const index_17 = require("../union/index");
 const type_3 = require("../guard/type");
-function MappedKey(T) {
-    return {
-        [index_2.Kind]: 'MappedKey',
-        keys: T
-    };
-}
-exports.MappedKey = MappedKey;
 function FromMappedResult(K, P) {
     return (K in P
-        ? FromMappedPropertyKey(K, P[K])
+        ? FromSchemaType(K, P[K])
         : (0, index_11.Never)());
 }
 function FromMappedKey(K, _) {
@@ -38,49 +32,41 @@ 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]) };
     }, {});
 }
-function FromMappedPropertyKey(K, T) {
-    return ((0, type_3.TOptional)(T) ? (0, index_13.Optional)(FromMappedPropertyKey(K, (0, index_3.Discard)(T, [index_2.OptionalKind]))) :
-        (0, type_3.TReadonly)(T) ? (0, index_15.Readonly)(FromMappedPropertyKey(K, (0, index_3.Discard)(T, [index_2.ReadonlyKind]))) :
+function FromSchemaType(K, T) {
+    return ((0, type_3.TOptional)(T) ? (0, index_13.Optional)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.OptionalKind]))) :
+        (0, type_3.TReadonly)(T) ? (0, index_15.Readonly)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.ReadonlyKind]))) :
             (0, type_3.TMappedResult)(T) ? FromMappedResult(K, T.properties) :
                 (0, type_3.TMappedKey)(T) ? FromMappedKey(K, T.keys) :
-                    (0, type_3.TConstructor)(T) ? (0, index_6.Constructor)(FromRest(K, T.parameters), FromMappedPropertyKey(K, T.returns)) :
-                        (0, type_3.TFunction)(T) ? (0, index_7.Function)(FromRest(K, T.parameters), FromMappedPropertyKey(K, T.returns)) :
-                            (0, type_3.TAsyncIterator)(T) ? (0, index_5.AsyncIterator)(FromMappedPropertyKey(K, T.items)) :
-                                (0, type_3.TIterator)(T) ? (0, index_9.Iterator)(FromMappedPropertyKey(K, T.items)) :
+                    (0, type_3.TConstructor)(T) ? (0, index_5.Constructor)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                        (0, type_3.TFunction)(T) ? (0, index_6.Function)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                            (0, type_3.TAsyncIterator)(T) ? (0, index_4.AsyncIterator)(FromSchemaType(K, T.items)) :
+                                (0, type_3.TIterator)(T) ? (0, index_9.Iterator)(FromSchemaType(K, T.items)) :
                                     (0, type_3.TIntersect)(T) ? (0, index_8.Intersect)(FromRest(K, T.allOf)) :
-                                        (0, type_3.TUnion)(T) ? (0, index_16.Union)(FromRest(K, T.anyOf)) :
-                                            (0, type_3.TObject)(T) ? (0, index_12.Object)(FromProperties(K, T.properties)) :
-                                                (0, type_3.TArray)(T) ? (0, index_4.Array)(FromMappedPropertyKey(K, T.items)) :
-                                                    (0, type_3.TPromise)(T) ? (0, index_14.Promise)(FromMappedPropertyKey(K, T.item)) :
-                                                        T);
+                                        (0, type_3.TUnion)(T) ? (0, index_17.Union)(FromRest(K, T.anyOf)) :
+                                            (0, type_3.TTuple)(T) ? (0, index_16.Tuple)(FromRest(K, T.items ?? [])) :
+                                                (0, type_3.TObject)(T) ? (0, index_12.Object)(FromProperties(K, T.properties)) :
+                                                    (0, type_3.TArray)(T) ? (0, index_3.Array)(FromSchemaType(K, T.items)) :
+                                                        (0, type_3.TPromise)(T) ? (0, index_14.Promise)(FromSchemaType(K, T.item)) :
+                                                            T);
 }
-exports.FromMappedPropertyKey = FromMappedPropertyKey;
-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) }
         : {});
 }
-exports.FromMappedPropertyKeys = FromMappedPropertyKeys;
-function MappedResult(properties) {
-    return {
-        [index_2.Kind]: 'MappedResult',
-        properties
-    };
-}
-exports.MappedResult = MappedResult;
 function Mapped(key, map, options = {}) {
-    const K = (0, type_1.TSchema)(key) ? (0, index_1.IndexedPropertyKeys)(key) : key;
-    const RT = map({ [index_2.Kind]: 'MappedKey', keys: K });
-    const R = FromMappedPropertyKeys(K, RT);
+    const K = (0, type_1.TSchema)(key) ? (0, index_7.IndexPropertyKeys)(key) : key;
+    const RT = map({ [index_1.Kind]: 'MappedKey', keys: K });
+    const R = FromMappedFunctionReturnType(K, RT);
     return (0, type_2.CloneType)((0, index_12.Object)(R), options);
 }
 exports.Mapped = Mapped;

package/build/require/type/omit/index.d.ts

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

package/build/require/type/omit/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./omit-mapped-result"), exports);
 __exportStar(require("./omit"), exports);

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

@@ -0,0 +1,15 @@
+import type { TSchema } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+import { type TOmit } from './omit';
+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/require/type/omit/omit-mapped-result.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmitMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const omit_1 = require("./omit");
+function MappedOmitPropertyKey(T, K) {
+    return {
+        [K]: (0, omit_1.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);
+}
+function OmitMappedResult(T, K) {
+    const P = MappedOmitProperties(T, K);
+    return (0, index_1.MappedResult)(P);
+}
+exports.OmitMappedResult = OmitMappedResult;

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

@@ -4,7 +4,9 @@ import { type TRecursive } from '../recursive/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TObject, type TProperties } from '../object/index';
-import { IndexedPropertyKeys } from '../indexed/index';
+import { type TIndexPropertyKeys } from '../indexed/index';
+import { TMappedKey } from '../mapped/index';
+import { type TOmitMappedResult } from './omit-mapped-result';
 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/require/type/omit/omit.js

@@ -8,6 +8,7 @@ const index_4 = require("../indexed/index");
 const index_5 = require("../discard/index");
 const index_6 = require("../symbols/index");
 const type_1 = require("../clone/type");
+const omit_mapped_result_1 = require("./omit-mapped-result");
 const type_2 = require("../guard/type");
 function FromIntersect(T, K) {
     return T.map((T) => OmitResolve(T, K));
@@ -32,9 +33,14 @@ function OmitResolve(T, K) {
 }
 exports.OmitResolve = OmitResolve;
 function Omit(T, K, options = {}) {
-    const I = (0, type_2.TSchema)(K) ? (0, index_4.IndexedPropertyKeys)(K) : K;
-    const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
-    const R = (0, type_1.CloneType)(OmitResolve(T, I), options);
-    return { ...D, ...R };
+    if ((0, type_2.TMappedKey)(K)) {
+        return (0, omit_mapped_result_1.OmitMappedResult)(T, K);
+    }
+    else {
+        const I = (0, type_2.TSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
+        const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
+        const R = (0, type_1.CloneType)(OmitResolve(T, I), options);
+        return { ...D, ...R };
+    }
 }
 exports.Omit = Omit;

package/build/require/type/pick/index.d.ts

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

package/build/require/type/pick/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./pick-mapped-result"), exports);
 __exportStar(require("./pick"), exports);

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

@@ -0,0 +1,15 @@
+import type { TSchema } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+import { type TPick } from './pick';
+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/require/type/pick/pick-mapped-result.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PickMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const pick_1 = require("./pick");
+function MappedPickPropertyKey(T, K) {
+    return {
+        [K]: (0, pick_1.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);
+}
+function PickMappedResult(T, K) {
+    const P = MappedPickProperties(T, K);
+    return (0, index_1.MappedResult)(P);
+}
+exports.PickMappedResult = PickMappedResult;

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

@@ -4,7 +4,9 @@ import { type TRecursive } from '../recursive/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TObject, type TProperties } from '../object/index';
-import { IndexedPropertyKeys } from '../indexed/index';
+import { type TIndexPropertyKeys } from '../indexed/index';
+import { TMappedKey } from '../mapped/index';
+import { type TPickMappedResult } from './pick-mapped-result';
 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/require/type/pick/pick.js

@@ -8,6 +8,7 @@ const index_4 = require("../indexed/index");
 const index_5 = require("../discard/index");
 const index_6 = require("../symbols/index");
 const type_1 = require("../clone/type");
+const pick_mapped_result_1 = require("./pick-mapped-result");
 const type_2 = require("../guard/type");
 function FromIntersect(T, K) {
     return T.map((T) => PickResolve(T, K));
@@ -28,9 +29,14 @@ function PickResolve(T, K) {
 }
 exports.PickResolve = PickResolve;
 function Pick(T, K, options = {}) {
-    const I = (0, type_2.TSchema)(K) ? (0, index_4.IndexedPropertyKeys)(K) : K;
-    const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
-    const R = (0, type_1.CloneType)(PickResolve(T, I), options);
-    return { ...D, ...R };
+    if ((0, type_2.TMappedKey)(K)) {
+        return (0, pick_mapped_result_1.PickMappedResult)(T, K);
+    }
+    else {
+        const I = (0, type_2.TSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
+        const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
+        const R = (0, type_1.CloneType)(PickResolve(T, I), options);
+        return { ...D, ...R };
+    }
 }
 exports.Pick = Pick;

package/build/require/type/record/record.js

@@ -21,11 +21,11 @@ function FromKeys(keys, T) {
 function FromTemplateLiteralKey(K, T) {
     const expression = (0, index_4.TemplateLiteralParseExact)(K.pattern);
     return ((0, index_4.IsTemplateLiteralFinite)(expression)
-        ? FromKeys((0, index_6.IndexedPropertyKeys)(K), T)
+        ? FromKeys((0, index_6.IndexPropertyKeys)(K), T)
         : FromPattern(K.pattern, T));
 }
 function FromUnionKey(K, T) {
-    return FromKeys((0, index_6.IndexedPropertyKeys)((0, index_3.Union)(K)), T);
+    return FromKeys((0, index_6.IndexPropertyKeys)((0, index_3.Union)(K)), T);
 }
 function FromLiteralKey(K, T) {
     return FromKeys([K.toString()], T);

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

@@ -6,25 +6,25 @@ import { type TConst } from '../const/index';
 import { type TDeref } from '../deref/index';
 import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index';
 import { type TExclude } from '../exclude/index';
-import { type TExtends, type MappedExtends, type MappedResultExtends } from '../extends/index';
+import { type TExtends, type TExtendsMappedResult, type TExtendsMappedResultFromResult } from '../extends/index';
 import { type TExtract } from '../extract/index';
-import { TIndex, type IndexedPropertyKeys, type TMappedIndex } from '../indexed/index';
+import { TIndex, type TIndexPropertyKeys, type TIndexMappedResult } from '../indexed/index';
 import { type IntegerOptions, type TInteger } from '../integer/index';
 import { type IntersectOptions, type IntersectResolve } from '../intersect/index';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index';
 import { type TKeyOf } from '../keyof/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
-import { type MappedFunction, type TMapped, type TMappedResult } from '../mapped/index';
+import { type TMappedFunction, type TMapped, type TMappedResult } from '../mapped/index';
 import { type TNever } from '../never/index';
 import { type TNot } from '../not/index';
 import { type TNull } from '../null/index';
 import { type TMappedKey } from '../mapped/index';
 import { type TNumber, type NumberOptions } from '../number/index';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
-import { type TOmit } from '../omit/index';
+import { type TOmit, type TOmitMappedResult } from '../omit/index';
 import { type TOptional } from '../optional/index';
 import { type TPartial } from '../partial/index';
-import { type TPick } from '../pick/index';
+import { type TPick, type TPickMappedResult } from '../pick/index';
 import { type TReadonly } from '../readonly/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type RecordResolve } from '../record/index';
@@ -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/require/value/transform/decode.js

@@ -44,7 +44,7 @@ function TIntersect(schema, references, value) {
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
-            ? { ...value, [key]: Visit((0, index_4.IndexedType)(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit((0, index_4.Index)(schema, [key]), references, value[key]) }
             : value;
     }, value);
     if (!(0, type_1.TTransform)(schema.unevaluatedProperties)) {

package/build/require/value/transform/encode.js

@@ -46,7 +46,7 @@ function TIntersect(schema, references, value) {
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return key in defaulted
-            ? { ...value, [key]: Visit((0, index_4.IndexedType)(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit((0, index_4.Index)(schema, [key]), references, value[key]) }
             : value;
     }, defaulted);
     if (!(0, type_1.TTransform)(schema.unevaluatedProperties)) {

package/package.json

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