@sinclair/typebox 0.32.0-dev-14 → 0.32.0-dev-15

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

@@ -1,5 +1,5 @@
 import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralGenerate } from '../template-literal/index.mjs';
-import { IntrinsicMappedResult } from './intrinsic-mapped-result.mjs';
+import { IntrinsicFromMappedKey } from './intrinsic-from-mapped-key.mjs';
 import { Literal } from '../literal/index.mjs';
 import { Union } from '../union/index.mjs';
 import { TMappedKey as IsMappedKeyType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType } from '../guard/type.mjs';
@@ -17,7 +17,7 @@ function ApplyUppercase(value) {
 function ApplyLowercase(value) {
     return value.toLowerCase();
 }
-function FromTemplateLiteral(schema, mode) {
+function FromTemplateLiteral(schema, mode, options) {
     const expression = TemplateLiteralParseExact(schema.pattern);
     const finite = IsTemplateLiteralFinite(expression);
     if (!finite)
@@ -26,7 +26,7 @@ function FromTemplateLiteral(schema, mode) {
     const literals = strings.map((value) => Literal(value));
     const mapped = FromRest(literals, mode);
     const union = Union(mapped);
-    return TemplateLiteral([union]);
+    return TemplateLiteral([union], options);
 }
 function FromLiteralValue(value, mode) {
     return (typeof value === 'string' ? (mode === 'Uncapitalize' ? ApplyUncapitalize(value) :
@@ -39,10 +39,10 @@ function FromRest(T, mode) {
     const [L, ...R] = T;
     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)) :
+export function Intrinsic(schema, mode, options = {}) {
+    return (IsMappedKeyType(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
+        IsTemplateLiteralType(schema) ? FromTemplateLiteral(schema, mode, schema) :
+            IsUnionType(schema) ? Union(FromRest(schema.anyOf, mode), options) :
+                IsLiteralType(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :
                     schema);
 }

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+import type { SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TKeyOf } from './keyof.mjs';
+type FromProperties<K extends TProperties> = ({
+    [K2 in keyof K]: TKeyOf<K[K2]>;
+});
+declare function FromProperties<K extends TProperties>(K: K, options: SchemaOptions): FromProperties<K>;
+type FromMappedResult<K extends TMappedResult> = (FromProperties<K['properties']>);
+declare function FromMappedResult<K extends TMappedResult>(K: K, options: SchemaOptions): FromMappedResult<K>;
+export type TKeyOfFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>> = (TMappedResult<P>);
+export declare function KeyOfFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
+export {};

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

@@ -0,0 +1,14 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { KeyOf } from './keyof.mjs';
+function FromProperties(K, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: KeyOf(K[K2], options) };
+    }, {});
+}
+function FromMappedResult(K, options) {
+    return FromProperties(K.properties, options);
+}
+export function KeyOfFromMappedResult(T, options) {
+    const P = FromMappedResult(T, options);
+    return MappedResult(P);
+}

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

@@ -1,12 +1,15 @@
 import type { TSchema } from '../schema/index.mjs';
 import type { Ensure } from '../helpers/index.mjs';
+import type { TMappedResult } from '../mapped/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';
+import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result.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 TMappedResult>(T: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
 export declare function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>;
 export {};

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

@@ -3,6 +3,8 @@ 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';
+import { KeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
+import { TMappedResult as IsMappedResultType } from '../guard/type.mjs';
 function FromLiterals(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -12,6 +14,11 @@ function FromLiterals(T) {
         : []);
 }
 export function KeyOf(T, options = {}) {
-    const K = UnionResolve(FromLiterals(KeyOfPropertyKeys(T)));
-    return CloneType(K, options);
+    if (IsMappedResultType(T)) {
+        return KeyOfFromMappedResult(T, options);
+    }
+    else {
+        const K = UnionResolve(FromLiterals(KeyOfPropertyKeys(T)));
+        return CloneType(K, options);
+    }
 }

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } 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 FromPropertyKey<T extends TSchema, K extends PropertyKey> = {
+    [_ in K]: TOmit<T, [K]>;
+};
+declare function FromPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K, options: SchemaOptions): FromPropertyKey<T, K>;
+type FromPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? FromPropertyKey<T, LK> & FromPropertyKeys<T, RK> : {});
+declare function FromPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): FromPropertyKeys<T, K>;
+type FromMappedKey<T extends TSchema, K extends TMappedKey> = (FromPropertyKeys<T, K['keys']>);
+declare function FromMappedKey<T extends TSchema, K extends TMappedKey>(T: T, K: K, options: SchemaOptions): FromMappedKey<T, K>;
+export type TOmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = FromMappedKey<T, K>> = (TMappedResult<P>);
+export declare function OmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = FromMappedKey<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
+export {};

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

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

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

@@ -6,7 +6,7 @@ import { type TUnion } from '../union/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TIndexPropertyKeys } from '../indexed/index.mjs';
 import { TMappedKey } from '../mapped/index.mjs';
-import { type TOmitMappedResult } from './omit-mapped-result.mjs';
+import { type TOmitFromMappedKey } from './omit-from-mapped-key.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>] : [];
@@ -16,7 +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 TMappedKey>(T: T, K: K): TOmitMappedResult<T, K>;
+export declare function Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitFromMappedKey<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

@@ -5,7 +5,7 @@ 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 { OmitMappedResult } from './omit-mapped-result.mjs';
+import { OmitFromMappedKey } from './omit-from-mapped-key.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));
@@ -30,7 +30,7 @@ export function OmitResolve(T, K) {
 }
 export function Omit(T, K, options = {}) {
     if (IsMappedKeyType(K)) {
-        return OmitMappedResult(T, K);
+        return OmitFromMappedKey(T, K, options);
     }
     else {
         const I = IsSchemaType(K) ? IndexPropertyKeys(K) : K;

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

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

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

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

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

@@ -0,0 +1,13 @@
+import type { SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TPartial } from './partial.mjs';
+type FromProperties<K extends TProperties> = ({
+    [K2 in keyof K]: TPartial<K[K2]>;
+});
+declare function FromProperties<K extends TProperties>(K: K, options: SchemaOptions): FromProperties<K>;
+type FromMappedResult<K extends TMappedResult> = (FromProperties<K['properties']>);
+declare function FromMappedResult<K extends TMappedResult>(K: K, options: SchemaOptions): FromMappedResult<K>;
+export type TPartialFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>> = (TMappedResult<P>);
+export declare function PartialFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
+export {};

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

@@ -0,0 +1,14 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Partial } from './partial.mjs';
+function FromProperties(K, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Partial(K[K2], options) };
+    }, {});
+}
+function FromMappedResult(K, options) {
+    return FromProperties(K.properties, options);
+}
+export function PartialFromMappedResult(T, options) {
+    const P = FromMappedResult(T, options);
+    return MappedResult(P);
+}

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

@@ -1,5 +1,6 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Evaluate } from '../helpers/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import { type TReadonly } from '../readonly/index.mjs';
@@ -7,6 +8,7 @@ import { type TRecursive } from '../recursive/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
+import { type TPartialFromMappedResult } from './partial-from-mapped-result.mjs';
 type FromIntersect<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PartialResolve<L>, ...FromIntersect<R>] : []);
 declare function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T>;
 type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PartialResolve<L>, ...FromUnion<R>] : []);
@@ -15,8 +17,9 @@ type FromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : T[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<T[K]>;
 }>;
 declare function FromProperties<T extends TProperties>(T: T): TProperties;
-export type PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
-export declare function PartialResolve<T extends TSchema>(T: T): PartialResolve<T>;
+type PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
+declare function PartialResolve<T extends TSchema>(T: T): PartialResolve<T>;
 export type TPartial<T extends TSchema> = PartialResolve<T>;
+export declare function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>;
 export declare function Partial<T extends TSchema>(T: T, options?: SchemaOptions): TPartial<T>;
 export {};

package/build/import/type/partial/partial.mjs

@@ -5,7 +5,8 @@ import { Union } from '../union/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 } from '../guard/type.mjs';
+import { PartialFromMappedResult } from './partial-from-mapped-result.mjs';
+import { TMappedResult as IsMappedResultType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType } from '../guard/type.mjs';
 function FromIntersect(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -23,14 +24,19 @@ function FromProperties(T) {
         return { ...Acc, [K]: Optional(T[K]) };
     }, {});
 }
-export function PartialResolve(T) {
+function PartialResolve(T) {
     return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf)) :
         IsUnionType(T) ? Union(FromUnion(T.anyOf)) :
             IsObjectType(T) ? Object(FromProperties(T.properties)) :
                 Object({}));
 }
 export function Partial(T, options = {}) {
-    const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(PartialResolve(T), options);
-    return { ...D, ...R };
+    if (IsMappedResultType(T)) {
+        return PartialFromMappedResult(T, options);
+    }
+    else {
+        const D = Discard(T, [TransformKind, '$id', 'required']);
+        const R = CloneType(PartialResolve(T), options);
+        return { ...D, ...R };
+    }
 }

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } 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 FromPropertyKey<T extends TSchema, K extends PropertyKey> = {
+    [_ in K]: TPick<T, [K]>;
+};
+declare function FromPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K, options: SchemaOptions): FromPropertyKey<T, K>;
+type FromPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? FromPropertyKey<T, LK> & FromPropertyKeys<T, RK> : {});
+declare function FromPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): FromPropertyKeys<T, K>;
+type FromMappedKey<T extends TSchema, K extends TMappedKey> = (FromPropertyKeys<T, K['keys']>);
+declare function FromMappedKey<T extends TSchema, K extends TMappedKey>(T: T, K: K, options: SchemaOptions): FromMappedKey<T, K>;
+export type TPickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = FromMappedKey<T, K>> = (TMappedResult<P>);
+export declare function PickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = FromMappedKey<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
+export {};

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

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

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

@@ -6,7 +6,7 @@ import { type TUnion } from '../union/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TIndexPropertyKeys } from '../indexed/index.mjs';
 import { TMappedKey } from '../mapped/index.mjs';
-import { type TPickMappedResult } from './pick-mapped-result.mjs';
+import { type TPickFromMappedKey } from './pick-from-mapped-key.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>] : [];
@@ -16,7 +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 TMappedKey>(T: T, K: K): TPickMappedResult<T, K>;
+export declare function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<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

@@ -5,7 +5,7 @@ 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 { PickMappedResult } from './pick-mapped-result.mjs';
+import { PickFromMappedKey } from './pick-from-mapped-key.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));
@@ -26,7 +26,7 @@ export function PickResolve(T, K) {
 }
 export function Pick(T, K, options = {}) {
     if (IsMappedKeyType(K)) {
-        return PickMappedResult(T, K);
+        return PickFromMappedKey(T, K, options);
     }
     else {
         const I = IsSchemaType(K) ? IndexPropertyKeys(K) : K;

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

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

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

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

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

@@ -0,0 +1,13 @@
+import type { SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TRequired } from './required.mjs';
+type FromProperties<K extends TProperties> = ({
+    [K2 in keyof K]: TRequired<K[K2]>;
+});
+declare function FromProperties<K extends TProperties>(K: K, options: SchemaOptions): FromProperties<K>;
+type FromMappedResult<K extends TMappedResult> = (FromProperties<K['properties']>);
+declare function FromMappedResult<K extends TMappedResult>(K: K, options: SchemaOptions): FromMappedResult<K>;
+export type TRequiredFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>> = (TMappedResult<P>);
+export declare function RequiredFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
+export {};

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

@@ -0,0 +1,14 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Required } from './required.mjs';
+function FromProperties(K, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Required(K[K2], options) };
+    }, {});
+}
+function FromMappedResult(K, options) {
+    return FromProperties(K.properties, options);
+}
+export function RequiredFromMappedResult(T, options) {
+    const P = FromMappedResult(T, options);
+    return MappedResult(P);
+}

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

@@ -1,5 +1,6 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Evaluate } from '../helpers/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import { type TReadonly } from '../readonly/index.mjs';
@@ -7,6 +8,7 @@ import { type TRecursive } from '../recursive/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
+import { type TRequiredFromMappedResult } from './required-from-mapped-result.mjs';
 type FromIntersect<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [RequiredResolve<L>, ...FromIntersect<R>] : []);
 declare function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T>;
 type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [RequiredResolve<L>, ...FromUnion<R>] : []);
@@ -15,8 +17,9 @@ type FromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : T[K] extends (TReadonly<infer S>) ? TReadonly<S> : T[K] extends (TOptional<infer S>) ? S : T[K];
 }>;
 declare function FromProperties<T extends TProperties>(T: T): TProperties;
-export type RequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<RequiredResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
-export declare function RequiredResolve<T extends TSchema>(T: T): RequiredResolve<T>;
+type RequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<RequiredResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
+declare function RequiredResolve<T extends TSchema>(T: T): RequiredResolve<T>;
 export type TRequired<T extends TSchema> = RequiredResolve<T>;
+export declare function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
 export declare function Required<T extends TSchema>(T: T, options?: SchemaOptions): TRequired<T>;
 export {};

package/build/import/type/required/required.mjs

@@ -4,7 +4,8 @@ import { Object } from '../object/index.mjs';
 import { OptionalKind, TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
-import { TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType } from '../guard/type.mjs';
+import { RequiredFromMappedResult } from './required-from-mapped-result.mjs';
+import { TMappedResult as IsMappedResultType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType } from '../guard/type.mjs';
 function FromIntersect(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -22,14 +23,19 @@ function FromProperties(T) {
         return { ...Acc, [K]: Discard(T[K], [OptionalKind]) };
     }, {});
 }
-export function RequiredResolve(T) {
+function RequiredResolve(T) {
     return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf)) :
         IsUnionType(T) ? Union(FromUnion(T.anyOf)) :
             IsObjectType(T) ? Object(FromProperties(T.properties)) :
                 Object({}));
 }
 export function Required(T, options = {}) {
-    const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(RequiredResolve(T), options);
-    return { ...D, ...R };
+    if (IsMappedResultType(T)) {
+        return RequiredFromMappedResult(T, options);
+    }
+    else {
+        const D = Discard(T, [TransformKind, '$id', 'required']);
+        const R = CloneType(RequiredResolve(T), options);
+        return { ...D, ...R };
+    }
 }