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

package/build/import/type/intrinsic/intrinsic.mjs

@@ -1,8 +1,8 @@
 import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralGenerate } from '../template-literal/index.mjs';
+import { IntrinsicMappedResult } from './intrinsic-mapped-result.mjs';
 import { Literal } from '../literal/index.mjs';
 import { Union } from '../union/index.mjs';
-import { TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType } from '../guard/type.mjs';
-import { CloneType } from '../clone/type.mjs';
+import { TMappedKey as IsMappedKeyType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType } from '../guard/type.mjs';
 function ApplyUncapitalize(value) {
     const [first, rest] = [value.slice(0, 1), value.slice(1)];
     return [first.toLowerCase(), rest].join('');
@@ -37,23 +37,12 @@ function FromLiteralValue(value, mode) {
 }
 function FromRest(T, mode) {
     const [L, ...R] = T;
-    return (T.length > 0 ? [IntrinsicResolve(L, mode), ...FromRest(R, mode)] : []);
-}
-export function IntrinsicResolve(schema, mode) {
-    return (IsTemplateLiteralType(schema) ? FromTemplateLiteral(schema, mode) :
-        IsUnionType(schema) ? Union(FromRest(schema.anyOf, mode)) :
-            IsLiteralType(schema) ? Literal(FromLiteralValue(schema.const, mode)) :
-                schema);
-}
-export function Uncapitalize(T, options = {}) {
-    return CloneType(IntrinsicResolve(T, 'Uncapitalize'), options);
-}
-export function Uppercase(T, options = {}) {
-    return CloneType(IntrinsicResolve(T, 'Uppercase'), options);
-}
-export function Lowercase(T, options = {}) {
-    return CloneType(IntrinsicResolve(T, 'Lowercase'), options);
-}
-export function Capitalize(T, options = {}) {
-    return CloneType(IntrinsicResolve(T, 'Capitalize'), options);
+    return (T.length > 0 ? [Intrinsic(L, mode), ...FromRest(R, mode)] : []);
+}
+export function Intrinsic(schema, mode) {
+    return (IsMappedKeyType(schema) ? IntrinsicMappedResult(schema, mode) :
+        IsTemplateLiteralType(schema) ? FromTemplateLiteral(schema, mode) :
+            IsUnionType(schema) ? Union(FromRest(schema.anyOf, mode)) :
+                IsLiteralType(schema) ? Literal(FromLiteralValue(schema.const, mode)) :
+                    schema);
 }

package/build/import/type/intrinsic/lowercase.d.mts

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

package/build/import/type/intrinsic/lowercase.mjs

@@ -0,0 +1,5 @@
+import { Intrinsic } from './intrinsic.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Lowercase(T, options = {}) {
+    return CloneType(Intrinsic(T, 'Lowercase'), options);
+}

package/build/import/type/intrinsic/uncapitalize.d.mts

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

package/build/import/type/intrinsic/uncapitalize.mjs

@@ -0,0 +1,5 @@
+import { Intrinsic } from './intrinsic.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Uncapitalize(T, options = {}) {
+    return CloneType(Intrinsic(T, 'Uncapitalize'), options);
+}

package/build/import/type/intrinsic/uppercase.d.mts

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

package/build/import/type/intrinsic/uppercase.mjs

@@ -0,0 +1,5 @@
+import { Intrinsic } from './intrinsic.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Uppercase(T, options = {}) {
+    return CloneType(Intrinsic(T, 'Uppercase'), options);
+}

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

@@ -1,3 +1,2 @@
-export * from './keyof-string.mjs';
-export * from './keyof-type.mjs';
+export * from './keyof-property-keys.mjs';
 export * from './keyof.mjs';

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

@@ -1,3 +1,2 @@
-export * from './keyof-string.mjs';
-export * from './keyof-type.mjs';
+export * from './keyof-property-keys.mjs';
 export * from './keyof.mjs';

package/build/import/type/keyof/{keyof-string.d.mts → keyof-property-keys.d.mts}

@@ -7,7 +7,7 @@ import type { TTuple } from '../tuple/index.mjs';
 import type { TArray } from '../array/index.mjs';
 import type { TObject, TProperties } from '../object/index.mjs';
 import { OperatorUnionMany, OperatorIntersectMany } from '../operators/index.mjs';
-type FromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [KeyOfStringResolve<L>, ...FromRest<R>] : []);
+type FromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [KeyOfPropertyKeys<L>, ...FromRest<R>] : []);
 declare function FromRest<T extends TSchema[]>(T: [...T]): FromRest<T>;
 type FromIntersect<T extends TSchema[], C extends PropertyKey[][] = FromRest<T>> = (OperatorUnionMany<C>);
 declare function FromIntersect<T extends TSchema[]>(T: [...T], C?: FromRest<T>): FromIntersect<T>;
@@ -21,8 +21,8 @@ type FromArray<_ extends TSchema> = ([
 declare function FromArray<_ extends TSchema>(_: _): FromArray<_>;
 type FromProperties<T extends TProperties> = (UnionToTuple<keyof T>);
 declare function FromProperties<T extends TProperties>(T: T): FromProperties<T>;
-export type KeyOfStringResolve<T extends TSchema> = (T extends TRecursive<infer S> ? KeyOfStringResolve<S> : T extends TIntersect<infer S> ? FromIntersect<S> : T extends TUnion<infer S> ? FromUnion<S> : T extends TTuple<infer S> ? FromTuple<S> : T extends TArray<infer S> ? FromArray<S> : T extends TObject<infer S> ? FromProperties<S> : [
+export type KeyOfPropertyKeys<T extends TSchema> = (T extends TRecursive<infer S> ? KeyOfPropertyKeys<S> : T extends TIntersect<infer S> ? FromIntersect<S> : T extends TUnion<infer S> ? FromUnion<S> : T extends TTuple<infer S> ? FromTuple<S> : T extends TArray<infer S> ? FromArray<S> : T extends TObject<infer S> ? FromProperties<S> : [
 ]);
-export declare function KeyOfStringResolve<T extends TSchema>(T: T): KeyOfStringResolve<T>;
-export declare function KeyOfStringResolvePattern(schema: TSchema): string;
+export declare function KeyOfPropertyKeys<T extends TSchema>(T: T): KeyOfPropertyKeys<T>;
+export declare function KeyOfPattern(schema: TSchema): string;
 export {};

package/build/import/type/keyof/{keyof-string.mjs → keyof-property-keys.mjs}

@@ -4,7 +4,7 @@ import { TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTuple
 function FromRest(T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [KeyOfStringResolve(L), ...FromRest(R)]
+        ? [KeyOfPropertyKeys(L), ...FromRest(R)]
         : []);
 }
 function FromIntersect(T, C = FromRest(T)) {
@@ -36,7 +36,7 @@ function FromPatternProperties(patternProperties) {
             : key;
     });
 }
-export function KeyOfStringResolve(T) {
+export function KeyOfPropertyKeys(T) {
     return (IsIntersectType(T) ? FromIntersect(T.allOf) :
         IsUnionType(T) ? FromUnion(T.anyOf) :
             IsTupleType(T) ? FromTuple(T.items ?? []) :
@@ -46,9 +46,9 @@ export function KeyOfStringResolve(T) {
                             []);
 }
 let includePatternProperties = false;
-export function KeyOfStringResolvePattern(schema) {
+export function KeyOfPattern(schema) {
     includePatternProperties = true;
-    const keys = KeyOfStringResolve(schema);
+    const keys = KeyOfPropertyKeys(schema);
     includePatternProperties = false;
     const pattern = keys.map((key) => `(${key})`);
     return `^(${pattern.join('|')})$`;

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

@@ -1,4 +1,12 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import { KeyOfTypeResolve } from './keyof-type.mjs';
-export type TKeyOf<T extends TSchema> = KeyOfTypeResolve<T>;
-export declare function KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): KeyOfTypeResolve<T>;
+import type { TSchema } from '../schema/index.mjs';
+import type { Ensure } from '../helpers/index.mjs';
+import { type TLiteral, TLiteralValue } from '../literal/index.mjs';
+import { type TNumber } from '../number/index.mjs';
+import { type SchemaOptions } from '../schema/index.mjs';
+import { KeyOfPropertyKeys } from './keyof-property-keys.mjs';
+import { UnionResolve } from '../union/index.mjs';
+type FromLiterals<T extends TLiteralValue[]> = (T extends [infer L extends TLiteralValue, ...infer R extends TLiteralValue[]] ? L extends '[number]' ? [TNumber, ...FromLiterals<R>] : [TLiteral<L>, ...FromLiterals<R>] : []);
+declare function FromLiterals<T extends TLiteralValue[]>(T: [...T]): FromLiterals<T>;
+export type TKeyOf<T extends TSchema> = (Ensure<UnionResolve<FromLiterals<KeyOfPropertyKeys<T>>>>);
+export declare function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>;
+export {};

package/build/import/type/keyof/keyof.mjs

@@ -1,6 +1,17 @@
-import { KeyOfTypeResolve } from './keyof-type.mjs';
+import { Literal } from '../literal/index.mjs';
+import { Number } from '../number/index.mjs';
+import { KeyOfPropertyKeys } from './keyof-property-keys.mjs';
+import { UnionResolve } from '../union/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-export function KeyOf(schema, options = {}) {
-    const K = KeyOfTypeResolve(schema);
+function FromLiterals(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? L === '[number]'
+            ? [Number(), ...FromLiterals(R)]
+            : [Literal(L), ...FromLiterals(R)]
+        : []);
+}
+export function KeyOf(T, options = {}) {
+    const K = UnionResolve(FromLiterals(KeyOfPropertyKeys(T)));
     return CloneType(K, options);
 }

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,9 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+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/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,24 +1,40 @@
 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 { Kind } from '../symbols/index.mjs';
-export interface TMappedKey<T extends PropertyKey[] = PropertyKey[]> extends TSchema {
-    [Kind]: 'MappedKey';
-    static: T[number];
-    anyOf: [];
-}
-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 {
-    [Kind]: 'MappedResult';
-    static: Static<O, this['params']>;
-    properties: P;
-}
-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;
+import type { Ensure, Evaluate } from '../helpers/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';
+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 TTuple } from '../tuple/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+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[]] ? [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]: FromSchemaType<K, T[K2]>;
+}>> = R;
+declare function FromProperties<K extends PropertyKey, T extends TProperties>(K: K, T: T): FromProperties<K, T>;
+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,14 +1,68 @@
-import { Object } from '../object/index.mjs';
-import { Literal } from '../literal/index.mjs';
-import { IndexedKeyResolve } from '../indexed/indexed-key.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 { IndexPropertyKeys } from '../indexed/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 { Tuple } from '../tuple/index.mjs';
+import { Union } from '../union/index.mjs';
+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
+        ? FromSchemaType(K, P[K])
+        : Never());
+}
+function FromMappedKey(K, _) {
+    return Literal(K);
+}
+function FromRest(K, T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [FromSchemaType(K, L), ...FromRest(K, R)]
+        : []);
+}
+function FromProperties(K, T) {
+    return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: FromSchemaType(K, T[K2]) };
     }, {});
-    return Object(properties);
+}
+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), 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)) :
+                                            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);
+}
+function FromMappedFunctionReturnType(K, T) {
+    const [L, ...R] = K;
+    return (K.length > 0
+        ? { [L]: FromSchemaType(L, T), ...FromMappedFunctionReturnType(R, T) }
+        : {});
+}
+export function Mapped(key, map, options = {}) {
+    const K = IsSchemaType(key) ? IndexPropertyKeys(key) : key;
+    const RT = map({ [Kind]: 'MappedKey', keys: K });
+    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 { IndexedKeyResolve } 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[] = IndexedKeyResolve<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 { IndexedKeyResolve } 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) ? IndexedKeyResolve(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 { IndexedKeyResolve } 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[] = IndexedKeyResolve<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 { IndexedKeyResolve } 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) ? IndexedKeyResolve(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 };
+    }
 }