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

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

@@ -14,5 +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("./keyof-from-mapped-result"), exports);
 __exportStar(require("./keyof-property-keys"), exports);
 __exportStar(require("./keyof"), exports);

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

@@ -0,0 +1,13 @@
+import type { SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TKeyOf } from './keyof';
+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/require/type/keyof/keyof-from-mapped-result.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyOfFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const keyof_1 = require("./keyof");
+function FromProperties(K, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, keyof_1.KeyOf)(K[K2], options) };
+    }, {});
+}
+function FromMappedResult(K, options) {
+    return FromProperties(K.properties, options);
+}
+function KeyOfFromMappedResult(T, options) {
+    const P = FromMappedResult(T, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.KeyOfFromMappedResult = KeyOfFromMappedResult;

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

@@ -1,12 +1,15 @@
 import type { TSchema } from '../schema/index';
 import type { Ensure } from '../helpers/index';
+import type { TMappedResult } from '../mapped/index';
 import { type TLiteral, TLiteralValue } from '../literal/index';
 import { type TNumber } from '../number/index';
 import { type SchemaOptions } from '../schema/index';
 import { KeyOfPropertyKeys } from './keyof-property-keys';
-import { UnionResolve } from '../union/index';
+import { UnionEvaluated } from '../union/index';
+import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result';
 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 type TKeyOf<T extends TSchema> = (Ensure<UnionEvaluated<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/require/type/keyof/keyof.js

@@ -6,6 +6,8 @@ const index_2 = require("../number/index");
 const keyof_property_keys_1 = require("./keyof-property-keys");
 const index_3 = require("../union/index");
 const type_1 = require("../clone/type");
+const keyof_from_mapped_result_1 = require("./keyof-from-mapped-result");
+const type_2 = require("../guard/type");
 function FromLiterals(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -15,7 +17,12 @@ function FromLiterals(T) {
         : []);
 }
 function KeyOf(T, options = {}) {
-    const K = (0, index_3.UnionResolve)(FromLiterals((0, keyof_property_keys_1.KeyOfPropertyKeys)(T)));
-    return (0, type_1.CloneType)(K, options);
+    if ((0, type_2.TMappedResult)(T)) {
+        return (0, keyof_from_mapped_result_1.KeyOfFromMappedResult)(T, options);
+    }
+    else {
+        const K = (0, index_3.UnionEvaluated)(FromLiterals((0, keyof_property_keys_1.KeyOfPropertyKeys)(T)));
+        return (0, type_1.CloneType)(K, options);
+    }
 }
 exports.KeyOf = KeyOf;

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

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mapped = void 0;
-const type_1 = require("../guard/type");
 const index_1 = require("../symbols/index");
-const type_2 = require("../clone/type");
+const type_1 = require("../clone/type");
 const index_2 = require("../discard/index");
 const index_3 = require("../array/index");
 const index_4 = require("../async-iterator/index");
@@ -20,7 +19,7 @@ const index_14 = require("../readonly/index");
 const index_15 = require("../tuple/index");
 const index_16 = require("../union/index");
 const mapped_result_1 = require("./mapped-result");
-const type_3 = require("../guard/type");
+const type_2 = require("../guard/type");
 function FromMappedResult(K, P) {
     return (K in P
         ? FromSchemaType(K, P[K])
@@ -48,20 +47,20 @@ function FromProperties(K, T) {
     }, {});
 }
 function FromSchemaType(K, T) {
-    return ((0, type_3.TOptional)(T) ? (0, index_12.Optional)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.OptionalKind]))) :
-        (0, type_3.TReadonly)(T) ? (0, index_14.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_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.TTuple)(T) ? (0, index_15.Tuple)(FromRest(K, T.items ?? [])) :
-                                                (0, type_3.TObject)(T) ? (0, index_11.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_13.Promise)(FromSchemaType(K, T.item)) :
+    return ((0, type_2.TOptional)(T) ? (0, index_12.Optional)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.OptionalKind]))) :
+        (0, type_2.TReadonly)(T) ? (0, index_14.Readonly)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.ReadonlyKind]))) :
+            (0, type_2.TMappedResult)(T) ? FromMappedResult(K, T.properties) :
+                (0, type_2.TMappedKey)(T) ? FromMappedKey(K, T.keys) :
+                    (0, type_2.TConstructor)(T) ? (0, index_5.Constructor)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                        (0, type_2.TFunction)(T) ? (0, index_6.Function)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                            (0, type_2.TAsyncIterator)(T) ? (0, index_4.AsyncIterator)(FromSchemaType(K, T.items)) :
+                                (0, type_2.TIterator)(T) ? (0, index_9.Iterator)(FromSchemaType(K, T.items)) :
+                                    (0, type_2.TIntersect)(T) ? (0, index_8.Intersect)(FromRest(K, T.allOf)) :
+                                        (0, type_2.TUnion)(T) ? (0, index_16.Union)(FromRest(K, T.anyOf)) :
+                                            (0, type_2.TTuple)(T) ? (0, index_15.Tuple)(FromRest(K, T.items ?? [])) :
+                                                (0, type_2.TObject)(T) ? (0, index_11.Object)(FromProperties(K, T.properties)) :
+                                                    (0, type_2.TArray)(T) ? (0, index_3.Array)(FromSchemaType(K, T.items)) :
+                                                        (0, type_2.TPromise)(T) ? (0, index_13.Promise)(FromSchemaType(K, T.item)) :
                                                             T);
 }
 function FromMappedFunctionReturnType(K, T) {
@@ -71,9 +70,9 @@ function FromMappedFunctionReturnType(K, T) {
         : {});
 }
 function Mapped(key, map, options = {}) {
-    const K = (0, type_1.TSchema)(key) ? (0, index_7.IndexPropertyKeys)(key) : key;
+    const K = (0, type_2.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_11.Object)(R), options);
+    return (0, type_1.CloneType)((0, index_11.Object)(R), options);
 }
 exports.Mapped = Mapped;

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

@@ -4,8 +4,6 @@ import type { Evaluate } from '../helpers/index';
 import type { TReadonly } from '../readonly/index';
 import type { TOptional } from '../optional/index';
 import { Kind } from '../symbols/index';
-export type TPropertyKey = string | number;
-export type TProperties = Record<TPropertyKey, TSchema>;
 type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
 }[keyof T];
@@ -16,10 +14,12 @@ type OptionalPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never;
 }[keyof T];
 type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
-type PropertiesResolve<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
-export type ObjectResolve<T extends TProperties, P extends unknown[]> = PropertiesResolve<T, {
+type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
+export type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
     [K in keyof T]: Static<T[K], P>;
 }>;
+export type TPropertyKey = string | number;
+export type TProperties = Record<TPropertyKey, TSchema>;
 export type TAdditionalProperties = undefined | TSchema | boolean;
 export interface ObjectOptions extends SchemaOptions {
     additionalProperties?: TAdditionalProperties;
@@ -28,7 +28,7 @@ export interface ObjectOptions extends SchemaOptions {
 }
 export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
     [Kind]: 'Object';
-    static: ObjectResolve<T, this['params']>;
+    static: ObjectStatic<T, this['params']>;
     additionalProperties?: TAdditionalProperties;
     type: 'object';
     properties: T;

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

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

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

@@ -14,5 +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-from-mapped-key"), exports);
 __exportStar(require("./omit"), exports);

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

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

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

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

@@ -6,7 +6,7 @@ import { type TUnion } from '../union/index';
 import { type TObject, type TProperties } from '../object/index';
 import { type TIndexPropertyKeys } from '../indexed/index';
 import { TMappedKey } from '../mapped/index';
-import { type TOmitMappedResult } from './omit-mapped-result';
+import { type TOmitFromMappedKey } from './omit-from-mapped-key';
 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/require/type/omit/omit.js

@@ -8,7 +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 omit_from_mapped_key_1 = require("./omit-from-mapped-key");
 const type_2 = require("../guard/type");
 function FromIntersect(T, K) {
     return T.map((T) => OmitResolve(T, K));
@@ -34,7 +34,7 @@ function OmitResolve(T, K) {
 exports.OmitResolve = OmitResolve;
 function Omit(T, K, options = {}) {
     if ((0, type_2.TMappedKey)(K)) {
-        return (0, omit_mapped_result_1.OmitMappedResult)(T, K);
+        return (0, omit_from_mapped_key_1.OmitFromMappedKey)(T, K, options);
     }
     else {
         const I = (0, type_2.TSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;

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

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

package/build/require/type/partial/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("./partial-from-mapped-result"), exports);
 __exportStar(require("./partial"), exports);

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

@@ -0,0 +1,13 @@
+import type { SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TPartial } from './partial';
+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/require/type/partial/partial-from-mapped-result.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartialFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const partial_1 = require("./partial");
+function FromProperties(K, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, partial_1.Partial)(K[K2], options) };
+    }, {});
+}
+function FromMappedResult(K, options) {
+    return FromProperties(K.properties, options);
+}
+function PartialFromMappedResult(T, options) {
+    const P = FromMappedResult(T, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.PartialFromMappedResult = PartialFromMappedResult;

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

@@ -1,5 +1,6 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Evaluate } from '../helpers/index';
+import type { TMappedResult } from '../mapped/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type TOptional } from '../optional/index';
 import { type TReadonly } from '../readonly/index';
@@ -7,6 +8,7 @@ import { type TRecursive } from '../recursive/index';
 import { type TObject, type TProperties } from '../object/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
+import { type TPartialFromMappedResult } from './partial-from-mapped-result';
 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/require/type/partial/partial.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Partial = exports.PartialResolve = void 0;
+exports.Partial = void 0;
 const index_1 = require("../optional/index");
 const index_2 = require("../object/index");
 const index_3 = require("../intersect/index");
@@ -8,6 +8,7 @@ const index_4 = require("../union/index");
 const index_5 = require("../discard/index");
 const index_6 = require("../symbols/index");
 const type_1 = require("../clone/type");
+const partial_from_mapped_result_1 = require("./partial-from-mapped-result");
 const type_2 = require("../guard/type");
 function FromIntersect(T) {
     const [L, ...R] = T;
@@ -32,10 +33,14 @@ function PartialResolve(T) {
             (0, type_2.TObject)(T) ? (0, index_2.Object)(FromProperties(T.properties)) :
                 (0, index_2.Object)({}));
 }
-exports.PartialResolve = PartialResolve;
 function Partial(T, options = {}) {
-    const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
-    const R = (0, type_1.CloneType)(PartialResolve(T), options);
-    return { ...D, ...R };
+    if ((0, type_2.TMappedResult)(T)) {
+        return (0, partial_from_mapped_result_1.PartialFromMappedResult)(T, options);
+    }
+    else {
+        const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
+        const R = (0, type_1.CloneType)(PartialResolve(T), options);
+        return { ...D, ...R };
+    }
 }
 exports.Partial = Partial;

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

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

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

@@ -14,5 +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-from-mapped-key"), exports);
 __exportStar(require("./pick"), exports);

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

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

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

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

@@ -6,7 +6,7 @@ import { type TUnion } from '../union/index';
 import { type TObject, type TProperties } from '../object/index';
 import { type TIndexPropertyKeys } from '../indexed/index';
 import { TMappedKey } from '../mapped/index';
-import { type TPickMappedResult } from './pick-mapped-result';
+import { type TPickFromMappedKey } from './pick-from-mapped-key';
 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/require/type/pick/pick.js

@@ -8,7 +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 pick_from_mapped_key_1 = require("./pick-from-mapped-key");
 const type_2 = require("../guard/type");
 function FromIntersect(T, K) {
     return T.map((T) => PickResolve(T, K));
@@ -30,7 +30,7 @@ function PickResolve(T, K) {
 exports.PickResolve = PickResolve;
 function Pick(T, K, options = {}) {
     if ((0, type_2.TMappedKey)(K)) {
-        return (0, pick_mapped_result_1.PickMappedResult)(T, K);
+        return (0, pick_from_mapped_key_1.PickFromMappedKey)(T, K, options);
     }
     else {
         const I = (0, type_2.TSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;

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

@@ -40,7 +40,6 @@ declare function FromIntegerKey<K extends TInteger, T extends TSchema>(_: K, T:
 type FromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
 declare function FromNumberKey<K extends TNumber, T extends TSchema>(_: K, T: T): FromIntegerKey<K, T>;
 export type RecordResolve<K extends TSchema, T extends TSchema> = K extends TEnum<infer S> ? FromEnumKey<S, T> : K extends TUnion<infer S> ? FromUnionKey<S, T> : K extends TTemplateLiteral ? FromTemplateLiteralKey<K, T> : K extends TLiteral<infer S> ? FromLiteralKey<S, T> : K extends TInteger ? FromIntegerKey<K, T> : K extends TNumber ? FromNumberKey<K, T> : K extends TString ? FromStringKey<K, T> : TNever;
-export declare function RecordResolve<K extends TSchema, T extends TSchema>(K: K, T: T): RecordResolve<K, T>;
 export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Record';
     static: Record<Assert<Static<K>, string | number>, Static<T, this['params']>>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Record = exports.RecordResolve = void 0;
+exports.Record = void 0;
 const index_1 = require("../object/index");
 const index_2 = require("../never/index");
 const index_3 = require("../union/index");
@@ -49,7 +49,6 @@ function RecordResolve(K, T) {
                         (0, type_2.TNumber)(K) ? FromNumberKey(K, T) :
                             (0, index_2.Never)());
 }
-exports.RecordResolve = RecordResolve;
 function Record(K, T, options = {}) {
     return (0, type_1.CloneType)(RecordResolve(K, T), options);
 }

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

@@ -6,9 +6,10 @@ export interface TThis extends TSchema {
     static: this['params'][0];
     $ref: string;
 }
-export type RecursiveResolve<T extends TSchema> = Static<T, [RecursiveResolve<T>]>;
+type RecursiveStatic<T extends TSchema> = Static<T, [RecursiveStatic<T>]>;
 export interface TRecursive<T extends TSchema> extends TSchema {
     [Hint]: 'Recursive';
-    static: RecursiveResolve<T>;
+    static: RecursiveStatic<T>;
 }
 export declare function Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
+export {};

package/build/require/type/recursive/recursive.js

@@ -10,10 +10,6 @@ function Recursive(callback, options = {}) {
         options.$id = `T${Ordinal++}`;
     const thisType = callback({ [index_1.Kind]: 'This', $ref: `${options.$id}` });
     thisType.$id = options.$id;
-    return (0, type_1.CloneType)({
-        ...options,
-        [index_1.Hint]: 'Recursive',
-        ...thisType,
-    });
+    return (0, type_1.CloneType)({ ...options, [index_1.Hint]: 'Recursive', ...thisType });
 }
 exports.Recursive = Recursive;

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

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

package/build/require/type/required/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("./required-from-mapped-result"), exports);
 __exportStar(require("./required"), exports);

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

@@ -0,0 +1,13 @@
+import type { SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TRequired } from './required';
+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/require/type/required/required-from-mapped-result.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const required_1 = require("./required");
+function FromProperties(K, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, required_1.Required)(K[K2], options) };
+    }, {});
+}
+function FromMappedResult(K, options) {
+    return FromProperties(K.properties, options);
+}
+function RequiredFromMappedResult(T, options) {
+    const P = FromMappedResult(T, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.RequiredFromMappedResult = RequiredFromMappedResult;

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

@@ -1,5 +1,6 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Evaluate } from '../helpers/index';
+import type { TMappedResult } from '../mapped/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type TOptional } from '../optional/index';
 import { type TReadonly } from '../readonly/index';
@@ -7,6 +8,7 @@ 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 { type TRequiredFromMappedResult } from './required-from-mapped-result';
 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 {};