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

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

@@ -4,7 +4,9 @@ import { type TRecursive } from '../recursive/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
-import { IndexedPropertyKeys } from '../indexed/index.mjs';
+import { type TIndexPropertyKeys } from '../indexed/index.mjs';
+import { TMappedKey } from '../mapped/index.mjs';
+import { type TOmitMappedResult } from './omit-mapped-result.mjs';
 type FromIntersect<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [OmitResolve<L, K>, ...FromIntersect<R, K>] : [];
 declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
 type FromUnion<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [OmitResolve<L, K>, ...FromUnion<R, K>] : [];
@@ -14,6 +16,7 @@ declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(
 export type OmitResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<OmitResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
 export declare function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): OmitResolve<T, K>;
 export type TOmit<T extends TSchema, K extends PropertyKey[]> = OmitResolve<T, K>;
-export declare function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
+export declare function Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitMappedResult<T, K>;
+export declare function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
 export declare function Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
 export {};

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

@@ -1,11 +1,12 @@
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
-import { IndexedPropertyKeys } from '../indexed/index.mjs';
+import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-import { TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
+import { OmitMappedResult } from './omit-mapped-result.mjs';
+import { TMappedKey as IsMappedKeyType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
 function FromIntersect(T, K) {
     return T.map((T) => OmitResolve(T, K));
 }
@@ -28,8 +29,13 @@ export function OmitResolve(T, K) {
                 Object({}));
 }
 export function Omit(T, K, options = {}) {
-    const I = IsSchemaType(K) ? IndexedPropertyKeys(K) : K;
-    const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(OmitResolve(T, I), options);
-    return { ...D, ...R };
+    if (IsMappedKeyType(K)) {
+        return OmitMappedResult(T, K);
+    }
+    else {
+        const I = IsSchemaType(K) ? IndexPropertyKeys(K) : K;
+        const D = Discard(T, [TransformKind, '$id', 'required']);
+        const R = CloneType(OmitResolve(T, I), options);
+        return { ...D, ...R };
+    }
 }

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { type TPick } from './pick.mjs';
+type MappedPickPropertyKey<T extends TSchema, K extends PropertyKey> = {
+    [_ in K]: TPick<T, [K]>;
+};
+declare function MappedPickPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): MappedPickPropertyKey<T, K>;
+type MappedPickPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? MappedPickPropertyKey<T, LK> & MappedPickPropertyKeys<T, RK> : {});
+declare function MappedPickPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): MappedPickPropertyKeys<T, K>;
+type MappedPickProperties<T extends TSchema, K extends TMappedKey> = (MappedPickPropertyKeys<T, K['keys']>);
+declare function MappedPickProperties<T extends TSchema, K extends TMappedKey>(T: T, K: K): MappedPickProperties<T, K>;
+export type TPickMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedPickProperties<T, K>> = (TMappedResult<P>);
+export declare function PickMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedPickProperties<T, K>>(T: T, K: K): TMappedResult<P>;
+export {};

package/build/import/type/pick/pick-mapped-result.mjs

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

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

@@ -4,7 +4,9 @@ import { type TRecursive } from '../recursive/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
-import { IndexedPropertyKeys } from '../indexed/index.mjs';
+import { type TIndexPropertyKeys } from '../indexed/index.mjs';
+import { TMappedKey } from '../mapped/index.mjs';
+import { type TPickMappedResult } from './pick-mapped-result.mjs';
 type FromIntersect<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PickResolve<L, K>, ...FromIntersect<R, K>] : [];
 declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
 type FromUnion<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PickResolve<L, K>, ...FromUnion<R, K>] : [];
@@ -14,6 +16,7 @@ declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(
 export type PickResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<PickResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
 export declare function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): PickResolve<T, K>;
 export type TPick<T extends TSchema, K extends PropertyKey[]> = PickResolve<T, K>;
-export declare function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+export declare function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickMappedResult<T, K>;
+export declare function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
 export declare function Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
 export {};

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

@@ -1,11 +1,12 @@
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
-import { IndexedPropertyKeys } from '../indexed/index.mjs';
+import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-import { TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
+import { PickMappedResult } from './pick-mapped-result.mjs';
+import { TMappedKey as IsMappedKeyType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType, } from '../guard/type.mjs';
 function FromIntersect(T, K) {
     return T.map((T) => PickResolve(T, K));
 }
@@ -24,8 +25,13 @@ export function PickResolve(T, K) {
                 Object({}));
 }
 export function Pick(T, K, options = {}) {
-    const I = IsSchemaType(K) ? IndexedPropertyKeys(K) : K;
-    const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(PickResolve(T, I), options);
-    return { ...D, ...R };
+    if (IsMappedKeyType(K)) {
+        return PickMappedResult(T, K);
+    }
+    else {
+        const I = IsSchemaType(K) ? IndexPropertyKeys(K) : K;
+        const D = Discard(T, [TransformKind, '$id', 'required']);
+        const R = CloneType(PickResolve(T, I), options);
+        return { ...D, ...R };
+    }
 }

package/build/import/type/record/record.mjs

@@ -3,11 +3,11 @@ import { Never } from '../never/index.mjs';
 import { Union } from '../union/index.mjs';
 import { IsTemplateLiteralFinite, TemplateLiteralParseExact } from '../template-literal/index.mjs';
 import { PatternStringExact, PatternNumberExact } from '../patterns/index.mjs';
-import { IndexedPropertyKeys } from '../indexed/index.mjs';
+import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { IsUndefined } from '../guard/value.mjs';
-import { TUnion as IsUnionType, TTemplateLiteral as IsTemplateLiteralType, TLiteral as IsLiteralType, TString as IsStringType, TInteger as IsIntegerType, TNumber as IsNumberType } from '../guard/type.mjs';
+import { TInteger as IsIntegerType, TLiteral as IsLiteralType, TNumber as IsNumberType, TString as IsStringType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, } from '../guard/type.mjs';
 function FromPattern(pattern, T) {
     return { [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: CloneType(T) } };
 }
@@ -18,11 +18,11 @@ function FromKeys(keys, T) {
 function FromTemplateLiteralKey(K, T) {
     const expression = TemplateLiteralParseExact(K.pattern);
     return (IsTemplateLiteralFinite(expression)
-        ? FromKeys(IndexedPropertyKeys(K), T)
+        ? FromKeys(IndexPropertyKeys(K), T)
         : FromPattern(K.pattern, T));
 }
 function FromUnionKey(K, T) {
-    return FromKeys(IndexedPropertyKeys(Union(K)), T);
+    return FromKeys(IndexPropertyKeys(Union(K)), T);
 }
 function FromLiteralKey(K, T) {
     return FromKeys([K.toString()], T);

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

@@ -6,25 +6,25 @@ 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 MappedExtends, type MappedResultExtends } from '../extends/index.mjs';
+import { type TExtends, type TExtendsMappedResult, type TExtendsMappedResultFromResult } from '../extends/index.mjs';
 import { type TExtract } from '../extract/index.mjs';
-import { TIndex, type IndexedPropertyKeys, type TMappedIndex } from '../indexed/index.mjs';
+import { TIndex, type TIndexPropertyKeys, type TIndexMappedResult } 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 TLiteral, type TLiteralValue } from '../literal/index.mjs';
-import { type MappedFunction, type TMapped, type TMappedResult } from '../mapped/index.mjs';
+import { type TMappedFunction, type TMapped, type TMappedResult } from '../mapped/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { type TNot } from '../not/index.mjs';
 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 } from '../omit/index.mjs';
+import { type TOmit, type TOmitMappedResult } from '../omit/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import { type TPartial } from '../partial/index.mjs';
-import { type TPick } from '../pick/index.mjs';
+import { type TPick, type TPickMappedResult } 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';
@@ -53,30 +53,32 @@ 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): MappedResultExtends<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): MappedExtends<L, R, T, F>;
+    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 TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<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): TMappedIndex<T, K>;
-    Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
+    Index<T extends TSchema, K extends TMappedKey>(T: T, K: K): TIndexMappedResult<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 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>;
-    Mapped<K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>, F extends MappedFunction<I> = MappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
-    Mapped<K extends PropertyKey[], F extends MappedFunction<K> = MappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
+    Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
+    Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
     Never(options?: SchemaOptions): TNever;
     Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;
     Null(options?: SchemaOptions): TNull;
     Number(options?: NumberOptions): TNumber;
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
+    Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitMappedResult<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 TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
-    Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickMappedResult<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>;

package/build/import/value/transform/decode.mjs

@@ -2,7 +2,7 @@ import { TTransform as IsTransformType, TSchema as IsSchemaType } from '../../ty
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
 import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
 import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
-import { IndexedType } from '../../type/indexed/index.mjs';
+import { Index } from '../../type/indexed/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { Check } from '../check/index.mjs';
 export class TransformDecodeCheckError extends Error {
@@ -44,7 +44,7 @@ function TIntersect(schema, references, value) {
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
-            ? { ...value, [key]: Visit(IndexedType(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit(Index(schema, [key]), references, value[key]) }
             : value;
     }, value);
     if (!IsTransformType(schema.unevaluatedProperties)) {

package/build/import/value/transform/encode.mjs

@@ -2,7 +2,7 @@ import { TTransform as IsTransformType, TSchema as IsSchemaType } from '../../ty
 import { Kind, TransformKind } from '../../type/symbols/index.mjs';
 import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
 import { KeyOfPropertyKeys } from '../../type/keyof/index.mjs';
-import { IndexedType } from '../../type/indexed/index.mjs';
+import { Index } from '../../type/indexed/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { Check } from '../check/index.mjs';
 export class TransformEncodeCheckError extends Error {
@@ -46,7 +46,7 @@ function TIntersect(schema, references, value) {
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return key in defaulted
-            ? { ...value, [key]: Visit(IndexedType(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit(Index(schema, [key]), references, value[key]) }
             : value;
     }, defaulted);
     if (!IsTransformType(schema.unevaluatedProperties)) {

package/build/require/index.d.ts

@@ -21,25 +21,25 @@ export { Extends, type TExtends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCh
 export { Extract, type TExtract } 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, type TIndex, type TMappedIndex, IndexedPropertyKeys, IndexedType, MappedIndex } from './type/indexed/index';
+export { Index, IndexPropertyKeys, IndexMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexMappedResult } 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 { Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase, IntrinsicResolve } from './type/intrinsic/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 { Literal, type TLiteral } from './type/literal/index';
-export { Mapped, type MappedKey as TMappedKey, type MappedFunction, type TMapped as TMappedResult } from './type/mapped/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';
 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 } from './type/omit/index';
+export { Omit, type TOmit, type TOmitMappedResult } 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 } from './type/pick/index';
+export { Pick, type TPick, type TPickMappedResult } 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';

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.Iterator = exports.Intersect = exports.Integer = exports.InstanceType = exports.MappedIndex = exports.IndexedType = exports.IndexedPropertyKeys = 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.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = exports.IntrinsicResolve = void 0;
+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;
 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; } });
@@ -65,9 +65,8 @@ var index_22 = require("./type/helpers/index");
 Object.defineProperty(exports, "Increment", { enumerable: true, get: function () { return index_22.Increment; } });
 var index_23 = require("./type/indexed/index");
 Object.defineProperty(exports, "Index", { enumerable: true, get: function () { return index_23.Index; } });
-Object.defineProperty(exports, "IndexedPropertyKeys", { enumerable: true, get: function () { return index_23.IndexedPropertyKeys; } });
-Object.defineProperty(exports, "IndexedType", { enumerable: true, get: function () { return index_23.IndexedType; } });
-Object.defineProperty(exports, "MappedIndex", { enumerable: true, get: function () { return index_23.MappedIndex; } });
+Object.defineProperty(exports, "IndexPropertyKeys", { enumerable: true, get: function () { return index_23.IndexPropertyKeys; } });
+Object.defineProperty(exports, "IndexMappedResult", { enumerable: true, get: function () { return index_23.IndexMappedResult; } });
 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,11 +76,11 @@ Object.defineProperty(exports, "Intersect", { enumerable: true, get: function ()
 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, "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; } });
 Object.defineProperty(exports, "Uppercase", { enumerable: true, get: function () { return index_28.Uppercase; } });
-Object.defineProperty(exports, "IntrinsicResolve", { enumerable: true, get: function () { return index_28.IntrinsicResolve; } });
 var index_29 = require("./type/keyof/index");
 Object.defineProperty(exports, "KeyOf", { enumerable: true, get: function () { return index_29.KeyOf; } });
 Object.defineProperty(exports, "KeyOfPropertyKeys", { enumerable: true, get: function () { return index_29.KeyOfPropertyKeys; } });
@@ -90,6 +89,8 @@ var index_30 = require("./type/literal/index");
 Object.defineProperty(exports, "Literal", { enumerable: true, get: function () { return index_30.Literal; } });
 var index_31 = require("./type/mapped/index");
 Object.defineProperty(exports, "Mapped", { enumerable: true, get: function () { return index_31.Mapped; } });
+Object.defineProperty(exports, "MappedKey", { enumerable: true, get: function () { return index_31.MappedKey; } });
+Object.defineProperty(exports, "MappedResult", { enumerable: true, get: function () { return index_31.MappedResult; } });
 var index_32 = require("./type/never/index");
 Object.defineProperty(exports, "Never", { enumerable: true, get: function () { return index_32.Never; } });
 var index_33 = require("./type/not/index");

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

@@ -1,10 +1,10 @@
 import type { UnionToTuple, Assert, Evaluate } from '../helpers/index';
 import { type TObject, type ObjectOptions } from '../object/index';
 import { type TIntersect } from '../intersect/index';
-import { IndexedType } from '../indexed/index';
+import { type TIndex } from '../indexed/index';
 type CompositeKeys<T extends TObject[]> = T extends [infer L extends TObject, ...infer R extends TObject[]] ? keyof L['properties'] | CompositeKeys<R> : never;
 type CompositeIndex<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L extends string, ...infer R extends string[]] ? {
-    [_ in L]: IndexedType<T, [L]>;
+    [_ in L]: TIndex<T, [L]>;
 } & CompositeIndex<T, R> : {};
 type CompositeReduce<T extends TObject[]> = UnionToTuple<CompositeKeys<T>> extends infer K ? Evaluate<CompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
 export type CompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<CompositeReduce<T>> : TObject<{}>;

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

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

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

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

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

@@ -1,13 +1,17 @@
 import type { TSchema } from '../schema/index';
 import type { TProperties } from '../object/index';
-import { type TMappedResult } from '../mapped/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 MappedResultExtendsPropertyKeys<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema> = ({
-    [K2 in keyof K]: TExtends<K[K2], U, L, R>;
-});
-declare function MappedResultExtendsPropertyKeys<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedResultExtendsPropertyKeys<K, U, L, R>;
-type MappedResultExtendsProperties<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema> = (MappedResultExtendsPropertyKeys<K['properties'], U, L, R>);
-declare function MappedResultExtendsProperties<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedResultExtendsProperties<K, U, L, R>;
-export type MappedResultExtends<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedResultExtendsProperties<T, U, L, R>> = (TMappedResult<P>);
-export declare function MappedResultExtends<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedResultExtendsProperties<T, U, L, R>>(T: T, U: U, L: L, R: R): TMappedResult<P>;
+type MappedExtendsPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
+    [_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>;
+};
+declare function MappedExtendsPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedExtendsPropertyKey<K, U, L, R>;
+type MappedExtendsPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? MappedExtendsPropertyKey<LK, U, L, R> & MappedExtendsPropertyKeys<RK, U, L, R> : {});
+declare function MappedExtendsPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema>(K: [...K], U: U, L: L, R: R): MappedExtendsPropertyKeys<K, U, L, R>;
+type MappedExtendsProperties<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema> = (MappedExtendsPropertyKeys<K['keys'], U, L, R>);
+declare function MappedExtendsProperties<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema>(K: K, U: U, L: L, R: R): MappedExtendsProperties<K, U, L, R>;
+export type TExtendsMappedResult<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedExtendsProperties<T, U, L, R>> = (TMappedResult<P>);
+export declare function ExtendsMappedResult<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = MappedExtendsProperties<T, U, L, R>>(T: T, U: U, L: L, R: R): TMappedResult<P>;
 export {};

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

@@ -1,18 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MappedResultExtends = void 0;
+exports.ExtendsMappedResult = void 0;
 const index_1 = require("../mapped/index");
+const index_2 = require("../literal/index");
 const extends_1 = require("./extends");
-function MappedResultExtendsPropertyKeys(K, U, L, R) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, extends_1.Extends)(K[K2], U, L, R) };
-    }, {});
+function MappedExtendsPropertyKey(K, U, L, R) {
+    return {
+        [K]: (0, extends_1.Extends)((0, index_2.Literal)(K), U, L, R)
+    };
 }
-function MappedResultExtendsProperties(K, U, L, R) {
-    return MappedResultExtendsPropertyKeys(K.properties, U, L, R);
+function MappedExtendsPropertyKeys(K, U, L, R) {
+    const [LK, ...RK] = K;
+    return (K.length > 0
+        ? { ...MappedExtendsPropertyKey(LK, U, L, R), ...MappedExtendsPropertyKeys(RK, U, L, R) }
+        : {});
 }
-function MappedResultExtends(T, U, L, R) {
-    const P = MappedResultExtendsProperties(T, U, L, R);
+function MappedExtendsProperties(K, U, L, R) {
+    return MappedExtendsPropertyKeys(K.keys, U, L, R);
+}
+function ExtendsMappedResult(T, U, L, R) {
+    const P = MappedExtendsProperties(T, U, L, R);
     return (0, index_1.MappedResult)(P);
 }
-exports.MappedResultExtends = MappedResultExtends;
+exports.ExtendsMappedResult = ExtendsMappedResult;

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 { MappedExtends } from './extends-mapped';
-import { MappedResultExtends } from './extends-mapped-result';
+import { type TExtendsMappedResult } from './extends-mapped-result';
+import { type TExtendsMappedResultFromResult } from './extends-mapped-result-from-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): MappedResultExtends<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): MappedExtends<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 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_1 = require("./extends-mapped");
 const extends_mapped_result_1 = require("./extends-mapped-result");
+const extends_mapped_result_from_result_1 = require("./extends-mapped-result-from-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_1.MappedResultExtends)(L, R, T, F), options) :
-        (0, type_1.TMappedKey)(L) ? (0, type_2.CloneType)((0, extends_mapped_1.MappedExtends)(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) :
             (0, type_2.CloneType)(ExtendsResolve(L, R, T, F), options));
 }
 exports.Extends = Extends;

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

@@ -1,5 +1,5 @@
 export * from './extends-check';
+export * from './extends-mapped-result-from-result';
 export * from './extends-mapped-result';
-export * from './extends-mapped';
 export * from './extends-undefined';
 export * from './extends';

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

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./extends-check"), exports);
+__exportStar(require("./extends-mapped-result-from-result"), exports);
 __exportStar(require("./extends-mapped-result"), exports);
-__exportStar(require("./extends-mapped"), exports);
 __exportStar(require("./extends-undefined"), exports);
 __exportStar(require("./extends"), exports);