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

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 };
+    }
 }

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

@@ -5,14 +5,14 @@ import { type TComposite } from '../composite/index.mjs';
 import { type TConst } from '../const/index.mjs';
 import { type TDeref } from '../deref/index.mjs';
 import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index.mjs';
-import { type TExclude } from '../exclude/index.mjs';
-import { type TExtends, type TExtendsMappedResult, type TExtendsMappedResultFromResult } from '../extends/index.mjs';
-import { type TExtract } from '../extract/index.mjs';
-import { TIndex, type TIndexPropertyKeys, type TIndexMappedResult } from '../indexed/index.mjs';
+import { type TExclude, type TExcludeFromMappedResult } from '../exclude/index.mjs';
+import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index.mjs';
+import { type TExtract, type TExtractFromMappedResult } from '../extract/index.mjs';
+import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from '../indexed/index.mjs';
 import { type IntegerOptions, type TInteger } from '../integer/index.mjs';
 import { type IntersectOptions, type IntersectResolve } from '../intersect/index.mjs';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index.mjs';
-import { type TKeyOf } from '../keyof/index.mjs';
+import { type TKeyOf, type TKeyOfFromMappedResult } from '../keyof/index.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TMappedFunction, type TMapped, type TMappedResult } from '../mapped/index.mjs';
 import { type TNever } from '../never/index.mjs';
@@ -21,16 +21,16 @@ import { type TNull } from '../null/index.mjs';
 import { type TMappedKey } from '../mapped/index.mjs';
 import { type TNumber, type NumberOptions } from '../number/index.mjs';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
-import { type TOmit, type TOmitMappedResult } from '../omit/index.mjs';
+import { type TOmit, type TOmitFromMappedKey } from '../omit/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
-import { type TPartial } from '../partial/index.mjs';
-import { type TPick, type TPickMappedResult } from '../pick/index.mjs';
+import { type TPartial, type TPartialFromMappedResult } from '../partial/index.mjs';
+import { type TPick, type TPickFromMappedKey } from '../pick/index.mjs';
 import { type TReadonly } from '../readonly/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type RecordResolve } from '../record/index.mjs';
 import { type TRecursive, type TThis } from '../recursive/index.mjs';
 import { type TRef } from '../ref/index.mjs';
-import { type TRequired } from '../required/index.mjs';
+import { type TRequired, type TRequiredFromMappedResult } from '../required/index.mjs';
 import { type TRest } from '../rest/index.mjs';
 import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
 import { type TString, type StringOptions } from '../string/index.mjs';
@@ -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/import/type/type/json.mjs

@@ -76,12 +76,12 @@ export class JsonTypeBuilder {
     Enum(item, options = {}) {
         return Enum(item, options);
     }
-    Extends(L, R, T, F, options = {}) {
-        return Extends(L, R, T, F, options);
-    }
     Exclude(unionType, excludedMembers, options = {}) {
         return Exclude(unionType, excludedMembers, options);
     }
+    Extends(L, R, T, F, options = {}) {
+        return Extends(L, R, T, F, options);
+    }
     Extract(type, union, options = {}) {
         return Extract(type, union, options);
     }

package/build/require/index.d.ts

@@ -16,18 +16,18 @@ export { ConstructorParameters, type TConstructorParameters } from './type/const
 export { Date, type TDate, type DateOptions } from './type/date/index';
 export { Deref, type TDeref } from './type/deref/index';
 export { Enum, type TEnum } from './type/enum/index';
-export { Exclude, type TExclude } from './type/exclude/index';
-export { Extends, type TExtends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index';
-export { Extract, type TExtract } from './type/extract/index';
+export { Exclude, type TExclude, type TExcludeFromMappedResult } from './type/exclude/index';
+export { Extends, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index';
+export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index';
 export { Function, type TFunction } from './type/function/index';
 export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index';
-export { Index, IndexPropertyKeys, IndexMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexMappedResult } from './type/indexed/index';
+export { Index, IndexPropertyKeys, IndexFromMappedKey, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from './type/indexed/index';
 export { InstanceType, type TInstanceType } from './type/instance-type/index';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index';
 export { Intersect, type TIntersect, type IntersectOptions } from './type/intersect/index';
 export { Iterator, type TIterator } from './type/iterator/index';
-export { Intrinsic, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index';
-export { KeyOf, type TKeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index';
+export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index';
+export { KeyOf, type TKeyOf, type KeyOfFromMappedResult, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index';
 export { Literal, type TLiteral } from './type/literal/index';
 export { Mapped, MappedKey, MappedResult, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction } from './type/mapped/index';
 export { Never, type TNever } from './type/never/index';
@@ -35,11 +35,11 @@ export { Not, type TNot } from './type/not/index';
 export { Null, type TNull } from './type/null/index';
 export { Number, type TNumber, type NumberOptions } from './type/number/index';
 export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index';
-export { Omit, type TOmit, type TOmitMappedResult } from './type/omit/index';
+export { Omit, type TOmit, type TOmitFromMappedKey } from './type/omit/index';
 export { Optional, type TOptional } from './type/optional/index';
 export { Parameters, type TParameters } from './type/parameters/index';
-export { Partial, type TPartial } from './type/partial/index';
-export { Pick, type TPick, type TPickMappedResult } from './type/pick/index';
+export { Partial, PartialFromMappedResult, type TPartial, type TPartialFromMappedResult } from './type/partial/index';
+export { Pick, type TPick, type TPickFromMappedKey } from './type/pick/index';
 export { Promise, type TPromise } from './type/promise/index';
 export { Readonly, type TReadonly } from './type/readonly/index';
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index';
@@ -47,7 +47,7 @@ export { Record, type TRecord } from './type/record/index';
 export { Recursive, type TRecursive, type TThis } from './type/recursive/index';
 export { Ref, type TRef } from './type/ref/index';
 export { RegExp, type TRegExp } from './type/regexp/index';
-export { Required, type TRequired } from './type/required/index';
+export { Required, type TRequired, type TRequiredFromMappedResult } from './type/required/index';
 export { Rest, type TRest } from './type/rest/index';
 export { ReturnType, type TReturnType } from './type/return-type/index';
 export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from './type/schema/index';

package/build/require/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Uppercase = exports.Uncapitalize = exports.Lowercase = exports.Capitalize = exports.Intrinsic = exports.Iterator = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexMappedResult = exports.IndexPropertyKeys = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
-exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = exports.Unsafe = exports.Unknown = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.Readonly = exports.Promise = exports.Pick = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = void 0;
+exports.Uncapitalize = exports.Lowercase = exports.Capitalize = exports.IntrinsicFromMappedKey = exports.Intrinsic = exports.Iterator = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexFromMappedKey = exports.IndexPropertyKeys = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
+exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = exports.Unsafe = exports.Unknown = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.Readonly = exports.Promise = exports.Pick = exports.PartialFromMappedResult = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = exports.Uppercase = void 0;
 var index_1 = require("./type/symbols/index");
 Object.defineProperty(exports, "Kind", { enumerable: true, get: function () { return index_1.Kind; } });
 Object.defineProperty(exports, "Hint", { enumerable: true, get: function () { return index_1.Hint; } });
@@ -66,7 +66,7 @@ Object.defineProperty(exports, "Increment", { enumerable: true, get: function ()
 var index_23 = require("./type/indexed/index");
 Object.defineProperty(exports, "Index", { enumerable: true, get: function () { return index_23.Index; } });
 Object.defineProperty(exports, "IndexPropertyKeys", { enumerable: true, get: function () { return index_23.IndexPropertyKeys; } });
-Object.defineProperty(exports, "IndexMappedResult", { enumerable: true, get: function () { return index_23.IndexMappedResult; } });
+Object.defineProperty(exports, "IndexFromMappedKey", { enumerable: true, get: function () { return index_23.IndexFromMappedKey; } });
 var index_24 = require("./type/instance-type/index");
 Object.defineProperty(exports, "InstanceType", { enumerable: true, get: function () { return index_24.InstanceType; } });
 var index_25 = require("./type/integer/index");
@@ -77,6 +77,7 @@ var index_27 = require("./type/iterator/index");
 Object.defineProperty(exports, "Iterator", { enumerable: true, get: function () { return index_27.Iterator; } });
 var index_28 = require("./type/intrinsic/index");
 Object.defineProperty(exports, "Intrinsic", { enumerable: true, get: function () { return index_28.Intrinsic; } });
+Object.defineProperty(exports, "IntrinsicFromMappedKey", { enumerable: true, get: function () { return index_28.IntrinsicFromMappedKey; } });
 Object.defineProperty(exports, "Capitalize", { enumerable: true, get: function () { return index_28.Capitalize; } });
 Object.defineProperty(exports, "Lowercase", { enumerable: true, get: function () { return index_28.Lowercase; } });
 Object.defineProperty(exports, "Uncapitalize", { enumerable: true, get: function () { return index_28.Uncapitalize; } });
@@ -109,6 +110,7 @@ var index_39 = require("./type/parameters/index");
 Object.defineProperty(exports, "Parameters", { enumerable: true, get: function () { return index_39.Parameters; } });
 var index_40 = require("./type/partial/index");
 Object.defineProperty(exports, "Partial", { enumerable: true, get: function () { return index_40.Partial; } });
+Object.defineProperty(exports, "PartialFromMappedResult", { enumerable: true, get: function () { return index_40.PartialFromMappedResult; } });
 var index_41 = require("./type/pick/index");
 Object.defineProperty(exports, "Pick", { enumerable: true, get: function () { return index_41.Pick; } });
 var index_42 = require("./type/promise/index");

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

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

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

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

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

@@ -1,11 +1,13 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { UnionToTuple, AssertRest, AssertType, Assert } from '../helpers/index';
+import type { TMappedResult } from '../mapped/index';
 import { type TTemplateLiteral } from '../template-literal/index';
 import { type TUnion } from '../union/index';
 import { type TNever } from '../never/index';
 import { type TLiteral } from '../literal/index';
 import { type Static } from '../static/index';
 import { UnionResolve } from '../union/index';
+import { type TExcludeFromMappedResult } from './exclude-from-mapped-result';
 type ExcludeTemplateLiteralResult<T extends string> = UnionResolve<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
@@ -14,7 +16,8 @@ type ExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTu
     [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K];
 }[number]>> extends infer R extends TSchema[] ? UnionResolve<R> : never;
 type ExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? ExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? ExcludeArray<S, U> : T extends U ? TNever : T;
-export declare function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExcludeResolve<L, R>;
+declare function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExcludeResolve<L, R>;
 export type TExclude<T extends TSchema, U extends TSchema> = ExcludeResolve<T, U>;
+export declare function Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
 export declare function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
 export {};

package/build/require/type/exclude/exclude.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Exclude = exports.ExcludeResolve = void 0;
+exports.Exclude = void 0;
 const index_1 = require("../template-literal/index");
 const index_2 = require("../union/index");
 const index_3 = require("../never/index");
 const index_4 = require("../extends/index");
 const type_1 = require("../clone/type");
+const exclude_from_mapped_result_1 = require("./exclude-from-mapped-result");
 const type_2 = require("../guard/type");
 function ExcludeResolve(L, R) {
     return ((0, type_2.TTemplateLiteral)(L) ? ExcludeResolve((0, index_1.TemplateLiteralToUnion)(L), R) :
@@ -17,9 +18,13 @@ function ExcludeResolve(L, R) {
                 (0, index_4.ExtendsCheck)(L, R) !== index_4.ExtendsResult.False ? (0, index_3.Never)() :
                     L);
 }
-exports.ExcludeResolve = ExcludeResolve;
 function Exclude(unionType, excludedMembers, options = {}) {
-    const E = ExcludeResolve(unionType, excludedMembers);
-    return (0, type_1.CloneType)(E, options);
+    if ((0, type_2.TMappedResult)(unionType)) {
+        return (0, exclude_from_mapped_result_1.ExcludeFromMappedResult)(unionType, excludedMembers, options);
+    }
+    else {
+        const E = ExcludeResolve(unionType, excludedMembers);
+        return (0, type_1.CloneType)(E, options);
+    }
 }
 exports.Exclude = Exclude;

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

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

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

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

@@ -0,0 +1,17 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import type { Assert } from '../helpers/index';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+import { TLiteral, TLiteralValue } from '../literal/index';
+import { type TExtends } from './extends';
+type FromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
+    [_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>;
+};
+declare function FromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromPropertyKey<K, U, L, R>;
+type FromPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? FromPropertyKey<LK, U, L, R> & FromPropertyKeys<RK, U, L, R> : {});
+declare function FromPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema>(K: [...K], U: U, L: L, R: R, options: SchemaOptions): FromPropertyKeys<K, U, L, R>;
+type FromMappedKey<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema> = (FromPropertyKeys<K['keys'], U, L, R>);
+declare function FromMappedKey<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R, options: SchemaOptions): FromMappedKey<K, U, L, R>;
+export type TExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedKey<T, U, L, R>> = (TMappedResult<P>);
+export declare function ExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = FromMappedKey<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
+export {};

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsFromMappedKey = void 0;
+const index_1 = require("../mapped/index");
+const index_2 = require("../literal/index");
+const extends_1 = require("./extends");
+function FromPropertyKey(K, U, L, R, options) {
+    return {
+        [K]: (0, extends_1.Extends)((0, index_2.Literal)(K), U, L, R, options)
+    };
+}
+function FromPropertyKeys(K, U, L, R, options) {
+    const [LK, ...RK] = K;
+    return (K.length > 0
+        ? { ...FromPropertyKey(LK, U, L, R, options), ...FromPropertyKeys(RK, U, L, R, options) }
+        : {});
+}
+function FromMappedKey(K, U, L, R, options) {
+    return FromPropertyKeys(K.keys, U, L, R, options);
+}
+function ExtendsFromMappedKey(T, U, L, R, options) {
+    const P = FromMappedKey(T, U, L, R, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.ExtendsFromMappedKey = ExtendsFromMappedKey;

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

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

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

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

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

@@ -3,12 +3,12 @@ import type { Static } from '../static/index';
 import { type TUnion } from '../union/index';
 import { TMappedKey, TMappedResult } from '../mapped/index';
 import { UnionToTuple } from '../helpers/index';
-import { type TExtendsMappedResult } from './extends-mapped-result';
-import { type TExtendsMappedResultFromResult } from './extends-mapped-result-from-result';
+import { type TExtendsFromMappedKey } from './extends-from-mapped-key';
+import { type TExtendsFromMappedResult } from './extends-from-mapped-result';
 type ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = ((Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ? UnionToTuple<O> extends [infer X extends TSchema, infer Y extends TSchema] ? TUnion<[X, Y]> : O : never);
 declare function ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U): ExtendsResolve<L, R, T, U>;
 export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema> = ExtendsResolve<L, R, T, F>;
-export declare function 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>;
-export declare function 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>;
+export declare function 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>;
+export declare function 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>;
 export declare function 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>;
 export {};

package/build/require/type/extends/extends.js

@@ -5,8 +5,8 @@ const type_1 = require("../guard/type");
 const index_1 = require("../union/index");
 const extends_check_1 = require("./extends-check");
 const type_2 = require("../clone/type");
-const extends_mapped_result_1 = require("./extends-mapped-result");
-const extends_mapped_result_from_result_1 = require("./extends-mapped-result-from-result");
+const extends_from_mapped_key_1 = require("./extends-from-mapped-key");
+const extends_from_mapped_result_1 = require("./extends-from-mapped-result");
 function ExtendsResolve(left, right, trueType, falseType) {
     const R = (0, extends_check_1.ExtendsCheck)(left, right);
     return (R === extends_check_1.ExtendsResult.Union ? (0, index_1.Union)([trueType, falseType]) :
@@ -14,8 +14,8 @@ function ExtendsResolve(left, right, trueType, falseType) {
             falseType);
 }
 function Extends(L, R, T, F, options = {}) {
-    return ((0, type_1.TMappedResult)(L) ? (0, type_2.CloneType)((0, extends_mapped_result_from_result_1.ExtendsMappedResultFromResult)(L, R, T, F), options) :
-        (0, type_1.TMappedKey)(L) ? (0, type_2.CloneType)((0, extends_mapped_result_1.ExtendsMappedResult)(L, R, T, F), options) :
+    return ((0, type_1.TMappedResult)(L) ? (0, extends_from_mapped_result_1.ExtendsFromMappedResult)(L, R, T, F, options) :
+        (0, type_1.TMappedKey)(L) ? (0, type_2.CloneType)((0, extends_from_mapped_key_1.ExtendsFromMappedKey)(L, R, T, F, options)) :
             (0, type_2.CloneType)(ExtendsResolve(L, R, T, F), options));
 }
 exports.Extends = Extends;