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

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/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 {};

package/build/require/type/required/required.js

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

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

@@ -5,14 +5,14 @@ import { type TComposite } from '../composite/index';
 import { type TConst } from '../const/index';
 import { type TDeref } from '../deref/index';
 import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index';
-import { type TExclude } from '../exclude/index';
-import { type TExtends, type TExtendsMappedResult, type TExtendsMappedResultFromResult } from '../extends/index';
-import { type TExtract } from '../extract/index';
-import { TIndex, type TIndexPropertyKeys, type TIndexMappedResult } from '../indexed/index';
+import { type TExclude, type TExcludeFromMappedResult } from '../exclude/index';
+import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index';
+import { type TExtract, type TExtractFromMappedResult } from '../extract/index';
+import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from '../indexed/index';
 import { type IntegerOptions, type TInteger } from '../integer/index';
 import { type IntersectOptions, type IntersectResolve } from '../intersect/index';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index';
-import { type TKeyOf } from '../keyof/index';
+import { type TKeyOf, type TKeyOfFromMappedResult } from '../keyof/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TMappedFunction, type TMapped, type TMappedResult } from '../mapped/index';
 import { type TNever } from '../never/index';
@@ -21,16 +21,16 @@ import { type TNull } from '../null/index';
 import { type TMappedKey } from '../mapped/index';
 import { type TNumber, type NumberOptions } from '../number/index';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
-import { type TOmit, type TOmitMappedResult } from '../omit/index';
+import { type TOmit, type TOmitFromMappedKey } from '../omit/index';
 import { type TOptional } from '../optional/index';
-import { type TPartial } from '../partial/index';
-import { type TPick, type TPickMappedResult } from '../pick/index';
+import { type TPartial, type TPartialFromMappedResult } from '../partial/index';
+import { type TPick, type TPickFromMappedKey } from '../pick/index';
 import { type TReadonly } from '../readonly/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type RecordResolve } from '../record/index';
 import { type TRecursive, type TThis } from '../recursive/index';
 import { type TRef } from '../ref/index';
-import { type TRequired } from '../required/index';
+import { type TRequired, type TRequiredFromMappedResult } from '../required/index';
 import { type TRest } from '../rest/index';
 import { type TSchema, type SchemaOptions } from '../schema/index';
 import { type TString, type StringOptions } from '../string/index';
@@ -53,16 +53,19 @@ export declare class JsonTypeBuilder {
     Const<T>(value: T, options?: SchemaOptions): TConst<T>;
     Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
     Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;
-    Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsMappedResultFromResult<L, R, T, F>;
-    Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsMappedResult<L, R, T, F>;
-    Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
+    Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
     Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
+    Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>;
+    Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedKey<L, R, T, F>;
+    Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
+    Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
     Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
-    Index<T extends TSchema, K extends TMappedKey>(T: T, K: K): TIndexMappedResult<T, K>;
+    Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
     Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
     Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;
     Integer(options?: IntegerOptions): TInteger;
     Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): IntersectResolve<T>;
+    KeyOf<T extends TMappedResult>(schema: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
     KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
     Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
     Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TLowercase<T>;
@@ -73,18 +76,20 @@ export declare class JsonTypeBuilder {
     Null(options?: SchemaOptions): TNull;
     Number(options?: NumberOptions): TNumber;
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitMappedResult<T, K>;
+    Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitFromMappedKey<T, K>;
     Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
     Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
+    Partial<T extends TMappedResult>(T: T, options?: ObjectOptions): TPartialFromMappedResult<T>;
     Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
-    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickMappedResult<T, K>;
+    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<T, K>;
     Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
     Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
     Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordResolve<K, T>;
     Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
     Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
     Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
-    Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
+    Required<T extends TMappedResult>(T: T, options?: ObjectOptions): TRequiredFromMappedResult<T>;
+    Required<T extends TSchema>(schema: T, options?: ObjectOptions): TRequired<T>;
     Rest<T extends TSchema>(schema: T): TRest<T>;
     String(options?: StringOptions): TString;
     TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;

package/build/require/type/type/json.js

@@ -79,12 +79,12 @@ class JsonTypeBuilder {
     Enum(item, options = {}) {
         return (0, index_7.Enum)(item, options);
     }
-    Extends(L, R, T, F, options = {}) {
-        return (0, index_9.Extends)(L, R, T, F, options);
-    }
     Exclude(unionType, excludedMembers, options = {}) {
         return (0, index_8.Exclude)(unionType, excludedMembers, options);
     }
+    Extends(L, R, T, F, options = {}) {
+        return (0, index_9.Extends)(L, R, T, F, options);
+    }
     Extract(type, union, options = {}) {
         return (0, index_10.Extract)(type, union, options);
     }

package/package.json

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