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

package/build/require/index.d.ts

@@ -21,15 +21,15 @@ 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, IndexedKeyResolve, IndexedTypeResolve } from './type/indexed/index';
+export { Index, type TIndex, type TMappedIndex, IndexedPropertyKeys, IndexedType, MappedIndex } 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 { KeyOf, type TKeyOf, KeyOfStringResolve, KeyOfStringResolvePattern, KeyOfTypeResolve } from './type/keyof/index';
+export { KeyOf, type TKeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index';
 export { Literal, type TLiteral } from './type/literal/index';
-export { Mapped, type TMappedKey, type MappedFunction, type TMappedResult } from './type/mapped/index';
+export { Mapped, type MappedKey as TMappedKey, type MappedFunction, type TMapped as TMappedResult } 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';

package/build/require/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntrinsicResolve = exports.Uppercase = exports.Uncapitalize = exports.Lowercase = exports.Capitalize = exports.Iterator = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexedTypeResolve = exports.IndexedKeyResolve = 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.KeyOfTypeResolve = exports.KeyOfStringResolvePattern = exports.KeyOfStringResolve = exports.KeyOf = void 0;
+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;
 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,8 +65,9 @@ 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, "IndexedKeyResolve", { enumerable: true, get: function () { return index_23.IndexedKeyResolve; } });
-Object.defineProperty(exports, "IndexedTypeResolve", { enumerable: true, get: function () { return index_23.IndexedTypeResolve; } });
+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; } });
 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");
@@ -83,9 +84,8 @@ Object.defineProperty(exports, "Uppercase", { enumerable: true, get: function ()
 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, "KeyOfStringResolve", { enumerable: true, get: function () { return index_29.KeyOfStringResolve; } });
-Object.defineProperty(exports, "KeyOfStringResolvePattern", { enumerable: true, get: function () { return index_29.KeyOfStringResolvePattern; } });
-Object.defineProperty(exports, "KeyOfTypeResolve", { enumerable: true, get: function () { return index_29.KeyOfTypeResolve; } });
+Object.defineProperty(exports, "KeyOfPropertyKeys", { enumerable: true, get: function () { return index_29.KeyOfPropertyKeys; } });
+Object.defineProperty(exports, "KeyOfPattern", { enumerable: true, get: function () { return index_29.KeyOfPattern; } });
 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");

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 { IndexedTypeResolve } from '../indexed/index';
+import { IndexedType } 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]: IndexedTypeResolve<T, [L]>;
+    [_ in L]: IndexedType<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/composite/composite.js

@@ -8,7 +8,7 @@ const index_4 = require("../indexed/index");
 const type_1 = require("../clone/type");
 function CompositeResolve(T) {
     const intersect = (0, index_2.Intersect)(T, {});
-    const keys = (0, index_3.KeyOfStringResolve)(intersect);
+    const keys = (0, index_3.KeyOfPropertyKeys)(intersect);
     const properties = keys.reduce((acc, key) => ({ ...acc, [key]: (0, index_4.Index)(intersect, [key]) }), {});
     return (0, index_1.Object)(properties);
 }

package/build/require/type/extends/extends-mapped-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 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>;
+export {};

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappedResultExtends = 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 MappedResultExtends(T, U, L, R) {
+    const P = MappedResultExtendsProperties(T, U, L, R);
+    return (0, index_1.MappedResult)(P);
+}
+exports.MappedResultExtends = MappedResultExtends;

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

@@ -0,0 +1,17 @@
+import type { TSchema } 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 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 MappedExtends<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 MappedExtends<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.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappedExtends = void 0;
+const index_1 = require("../mapped/index");
+const index_2 = require("../literal/index");
+const extends_1 = require("./extends");
+function MappedExtendsPropertyKey(K, U, L, R) {
+    return {
+        [K]: (0, extends_1.Extends)((0, index_2.Literal)(K), 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 MappedExtendsProperties(K, U, L, R) {
+    return MappedExtendsPropertyKeys(K.keys, U, L, R);
+}
+function MappedExtends(T, U, L, R) {
+    const P = MappedExtendsProperties(T, U, L, R);
+    return (0, index_1.MappedResult)(P);
+}
+exports.MappedExtends = MappedExtends;

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

@@ -1,8 +1,14 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Static } from '../static/index';
 import { type TUnion } from '../union/index';
+import { TMappedKey, TMappedResult } from '../mapped/index';
 import { UnionToTuple } from '../helpers/index';
-export 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);
-export 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>;
+import { MappedExtends } from './extends-mapped';
+import { MappedResultExtends } from './extends-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): 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 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

@@ -1,18 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Extends = exports.ExtendsResolve = void 0;
+exports.Extends = void 0;
+const type_1 = require("../guard/type");
 const index_1 = require("../union/index");
 const extends_check_1 = require("./extends-check");
-const type_1 = require("../clone/type");
+const type_2 = require("../clone/type");
+const extends_mapped_1 = require("./extends-mapped");
+const extends_mapped_result_1 = require("./extends-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]) :
         R === extends_check_1.ExtendsResult.True ? trueType :
             falseType);
 }
-exports.ExtendsResolve = ExtendsResolve;
 function Extends(L, R, T, F, options = {}) {
-    const E = ExtendsResolve(L, R, T, F);
-    return (0, type_1.CloneType)(E, 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) :
+            (0, type_2.CloneType)(ExtendsResolve(L, R, T, F), options));
 }
 exports.Extends = Extends;

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

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

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

@@ -15,5 +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"), exports);
+__exportStar(require("./extends-mapped"), exports);
 __exportStar(require("./extends-undefined"), exports);
 __exportStar(require("./extends"), exports);

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

@@ -15,11 +15,12 @@ import type { TInteger } from '../integer/index';
 import type { TIntersect } from '../intersect/index';
 import type { TIterator } from '../iterator/index';
 import type { TLiteral } from '../literal/index';
+import type { TMappedKey, TMappedResult } from '../mapped/index';
 import type { TNever } from '../never/index';
 import type { TNot } from '../not/index';
 import type { TNull } from '../null/index';
 import type { TNumber } from '../number/index';
-import type { TObject } from '../object/index';
+import type { TObject, TProperties } from '../object/index';
 import type { TOptional } from '../optional/index';
 import type { TPromise } from '../promise/index';
 import type { TReadonly } from '../readonly/index';
@@ -47,6 +48,7 @@ export declare function TConstructor(schema: unknown): schema is TConstructor;
 export declare function TDate(schema: unknown): schema is TDate;
 export declare function TFunction(schema: unknown): schema is TFunction;
 export declare function TInteger(schema: unknown): schema is TInteger;
+export declare function TProperties(schema: unknown): schema is TProperties;
 export declare function TIntersect(schema: unknown): schema is TIntersect;
 export declare function TIterator(schema: unknown): schema is TIterator;
 export declare function TKindOf<T extends string>(schema: unknown, kind: T): schema is Record<PropertyKey, unknown> & {
@@ -56,6 +58,8 @@ export declare function TLiteralString(schema: unknown): schema is TLiteral<stri
 export declare function TLiteralNumber(schema: unknown): schema is TLiteral<number>;
 export declare function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean>;
 export declare function TLiteral(schema: unknown): schema is TLiteral;
+export declare function TMappedKey(schema: unknown): schema is TMappedKey;
+export declare function TMappedResult(schema: unknown): schema is TMappedResult;
 export declare function TNever(schema: unknown): schema is TNever;
 export declare function TNot(schema: unknown): schema is TNot;
 export declare function TNull(schema: unknown): schema is TNull;

package/build/require/type/guard/type.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TSchema = exports.TKind = exports.TVoid = exports.TUnsafe = exports.TUnknown = exports.TUint8Array = exports.TUnion = exports.TUnionLiteral = exports.TUndefined = exports.TTuple = exports.TTransform = exports.TThis = exports.TTemplateLiteral = exports.TSymbol = exports.TString = exports.TRef = exports.TRecursive = exports.TRecord = exports.TPromise = exports.TObject = exports.TNumber = exports.TNull = exports.TNot = exports.TNever = exports.TLiteral = exports.TLiteralBoolean = exports.TLiteralNumber = exports.TLiteralString = exports.TKindOf = exports.TIterator = exports.TIntersect = exports.TInteger = exports.TFunction = exports.TDate = exports.TConstructor = exports.TBoolean = exports.TBigInt = exports.TAsyncIterator = exports.TArray = exports.TAny = exports.TOptional = exports.TReadonly = exports.TypeGuardUnknownTypeError = void 0;
+exports.TSchema = exports.TKind = exports.TVoid = exports.TUnsafe = exports.TUnknown = exports.TUint8Array = exports.TUnion = exports.TUnionLiteral = exports.TUndefined = exports.TTuple = exports.TTransform = exports.TThis = exports.TTemplateLiteral = exports.TSymbol = exports.TString = exports.TRef = exports.TRecursive = exports.TRecord = exports.TPromise = exports.TObject = exports.TNumber = exports.TNull = exports.TNot = exports.TNever = exports.TMappedResult = exports.TMappedKey = exports.TLiteral = exports.TLiteralBoolean = exports.TLiteralNumber = exports.TLiteralString = exports.TKindOf = exports.TIterator = exports.TIntersect = exports.TProperties = exports.TInteger = exports.TFunction = exports.TDate = exports.TConstructor = exports.TBoolean = exports.TBigInt = exports.TAsyncIterator = exports.TArray = exports.TAny = exports.TOptional = exports.TReadonly = exports.TypeGuardUnknownTypeError = void 0;
 const ValueGuard = require("./value");
 const index_1 = require("../symbols/index");
 class TypeGuardUnknownTypeError extends Error {
@@ -20,6 +20,8 @@ const KnownTypes = [
     'Intersect',
     'Iterator',
     'Literal',
+    'MappedKey',
+    'MappedResult',
     'Not',
     'Null',
     'Number',
@@ -172,6 +174,11 @@ function TInteger(schema) {
         IsOptionalNumber(schema.multipleOf));
 }
 exports.TInteger = TInteger;
+function TProperties(schema) {
+    return (ValueGuard.IsObject(schema) &&
+        Object.entries(schema).every(([key, schema]) => IsControlCharacterFree(key) && (0, index_2.TSchema)(schema)));
+}
+exports.TProperties = TProperties;
 function TIntersect(schema) {
     return (TKindOf(schema, 'Intersect') &&
         (ValueGuard.IsString(schema.type) && schema.type !== 'object' ? false : true) &&
@@ -212,6 +219,17 @@ function TLiteral(schema) {
         ValueGuard.IsString(schema.const)));
 }
 exports.TLiteral = TLiteral;
+function TMappedKey(schema) {
+    return (TKindOf(schema, 'MappedKey') &&
+        ValueGuard.IsArray(schema.keys) &&
+        schema.keys.every(key => ValueGuard.IsNumber(key) || ValueGuard.IsString(key)));
+}
+exports.TMappedKey = TMappedKey;
+function TMappedResult(schema) {
+    return (TKindOf(schema, 'MappedResult') &&
+        (0, index_4.TProperties)(schema.properties));
+}
+exports.TMappedResult = TMappedResult;
 function TNever(schema) {
     return (TKindOf(schema, 'Never') &&
         ValueGuard.IsObject(schema.not) &&
@@ -244,8 +262,7 @@ function TObject(schema) {
     return (TKindOf(schema, 'Object') &&
         schema.type === 'object' &&
         IsOptionalString(schema.$id) &&
-        ValueGuard.IsObject(schema.properties) &&
-        Object.entries(schema.properties).every(([key, schema]) => IsControlCharacterFree(key) && (0, index_2.TSchema)(schema)) &&
+        (0, index_4.TProperties)(schema.properties) &&
         IsAdditionalProperties(schema.additionalProperties) &&
         IsOptionalNumber(schema.minProperties) &&
         IsOptionalNumber(schema.maxProperties));
@@ -337,7 +354,7 @@ function TUndefined(schema) {
 }
 exports.TUndefined = TUndefined;
 function TUnionLiteral(schema) {
-    return (0, index_4.TUnion)(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
+    return (0, index_5.TUnion)(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
 }
 exports.TUnionLiteral = TUnionLiteral;
 function TUnion(schema) {
@@ -376,37 +393,39 @@ function TKind(schema) {
 }
 exports.TKind = TKind;
 function TSchema(schema) {
-    return (ValueGuard.IsObject(schema)) && ((0, index_5.TAny)(schema) ||
-        (0, index_6.TArray)(schema) ||
-        (0, index_7.TBoolean)(schema) ||
-        (0, index_8.TBigInt)(schema) ||
-        (0, index_9.TAsyncIterator)(schema) ||
-        (0, index_10.TConstructor)(schema) ||
-        (0, index_11.TDate)(schema) ||
-        (0, index_12.TFunction)(schema) ||
-        (0, index_13.TInteger)(schema) ||
-        (0, index_14.TIntersect)(schema) ||
-        (0, index_15.TIterator)(schema) ||
+    return (ValueGuard.IsObject(schema)) && ((0, index_6.TAny)(schema) ||
+        (0, index_7.TArray)(schema) ||
+        (0, index_8.TBoolean)(schema) ||
+        (0, index_9.TBigInt)(schema) ||
+        (0, index_10.TAsyncIterator)(schema) ||
+        (0, index_11.TConstructor)(schema) ||
+        (0, index_12.TDate)(schema) ||
+        (0, index_13.TFunction)(schema) ||
+        (0, index_14.TInteger)(schema) ||
+        (0, index_15.TIntersect)(schema) ||
+        (0, index_16.TIterator)(schema) ||
         (0, index_3.TLiteral)(schema) ||
-        (0, index_16.TNever)(schema) ||
-        (0, index_17.TNot)(schema) ||
-        (0, index_18.TNull)(schema) ||
-        (0, index_19.TNumber)(schema) ||
-        (0, index_20.TObject)(schema) ||
-        (0, index_21.TPromise)(schema) ||
-        (0, index_22.TRecord)(schema) ||
-        (0, index_23.TRef)(schema) ||
-        (0, index_24.TString)(schema) ||
-        (0, index_25.TSymbol)(schema) ||
-        (0, index_26.TTemplateLiteral)(schema) ||
-        (0, index_27.TThis)(schema) ||
-        (0, index_28.TTuple)(schema) ||
-        (0, index_29.TUndefined)(schema) ||
-        (0, index_4.TUnion)(schema) ||
-        (0, index_30.TUint8Array)(schema) ||
-        (0, index_31.TUnknown)(schema) ||
-        (0, index_32.TUnsafe)(schema) ||
-        (0, index_33.TVoid)(schema) ||
+        (0, index_17.TMappedKey)(schema) ||
+        (0, index_17.TMappedResult)(schema) ||
+        (0, index_18.TNever)(schema) ||
+        (0, index_19.TNot)(schema) ||
+        (0, index_20.TNull)(schema) ||
+        (0, index_21.TNumber)(schema) ||
+        (0, index_4.TObject)(schema) ||
+        (0, index_22.TPromise)(schema) ||
+        (0, index_23.TRecord)(schema) ||
+        (0, index_24.TRef)(schema) ||
+        (0, index_25.TString)(schema) ||
+        (0, index_26.TSymbol)(schema) ||
+        (0, index_27.TTemplateLiteral)(schema) ||
+        (0, index_28.TThis)(schema) ||
+        (0, index_29.TTuple)(schema) ||
+        (0, index_30.TUndefined)(schema) ||
+        (0, index_5.TUnion)(schema) ||
+        (0, index_31.TUint8Array)(schema) ||
+        (0, index_32.TUnknown)(schema) ||
+        (0, index_33.TUnsafe)(schema) ||
+        (0, index_34.TVoid)(schema) ||
         TKind(schema));
 }
 exports.TSchema = TSchema;

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

@@ -1,3 +1,4 @@
-export * from './indexed-key';
+export * from './indexed-mapped';
+export * from './indexed-property-keys';
 export * from './indexed-type';
 export * from './indexed';

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

@@ -14,6 +14,7 @@ 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("./indexed-key"), exports);
+__exportStar(require("./indexed-mapped"), exports);
+__exportStar(require("./indexed-property-keys"), exports);
 __exportStar(require("./indexed-type"), exports);
 __exportStar(require("./indexed"), exports);

package/build/require/type/indexed/indexed-mapped.d.ts

@@ -0,0 +1,16 @@
+import { type TSchema } from '../schema/index';
+import { type TProperties } from '../object/index';
+import { IndexedType } from './indexed-type';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+import { Evaluate } from '../helpers/index';
+type MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
+    [_ in K]: IndexedType<T, [K]>;
+};
+declare function MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): MappedIndexPropertyKey<T, K>;
+type MappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? MappedIndexPropertyKey<T, L> & MappedIndexPropertyKeys<T, R> : {});
+declare function MappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): MappedIndexPropertyKeys<T, K>;
+type MappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<MappedIndexPropertyKeys<T, K['keys']>>;
+declare function MappedIndexProperties<T extends TSchema, K extends TMappedKey>(T: T, K: K): MappedIndexProperties<T, K>;
+export type TMappedIndex<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedIndexProperties<T, K>> = TMappedResult<P>;
+export declare function MappedIndex<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedIndexProperties<T, K>>(T: T, K: K): TMappedResult<P>;
+export {};

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappedIndex = void 0;
+const indexed_type_1 = require("./indexed-type");
+const index_1 = require("../mapped/index");
+function MappedIndexPropertyKey(T, K) {
+    return { [K]: (0, indexed_type_1.IndexedType)(T, [K]) };
+}
+function MappedIndexPropertyKeys(T, K) {
+    const [L, ...R] = K;
+    return (K.length > 0
+        ? { ...MappedIndexPropertyKey(T, L), ...MappedIndexPropertyKeys(T, R) }
+        : {});
+}
+function MappedIndexProperties(T, K) {
+    return MappedIndexPropertyKeys(T, K.keys);
+}
+function MappedIndex(T, K) {
+    const P = MappedIndexProperties(T, K);
+    return (0, index_1.MappedResult)(P);
+}
+exports.MappedIndex = MappedIndex;

package/build/require/type/indexed/{indexed-key.d.ts → indexed-property-keys.d.ts}

@@ -6,11 +6,11 @@ import { type TSchema } from '../schema/index';
 import { type TUnion } from '../union/index';
 type FromTemplateLiteral<T extends TTemplateLiteral, F = IsTemplateLiteralFinite<T>> = (F extends true ? TemplateLiteralGenerate<T> extends infer R extends string[] ? R : [] : []);
 declare function FromTemplateLiteral<T extends TTemplateLiteral>(T: T): FromTemplateLiteral<T>;
-type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...IndexedKeyResolve<L>, ...FromUnion<R>] : []);
+type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...IndexedPropertyKeys<L>, ...FromUnion<R>] : []);
 declare function FromUnion<T extends TSchema[]>(T: T): FromUnion<T>;
 type FromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] : []);
 declare function FromLiteral<T extends TLiteralValue>(T: T): FromLiteral<T>;
-export type IndexedKeyResolve<T extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T> : T extends TUnion<infer S> ? FromUnion<S> : T extends TLiteral<infer S> ? FromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
+export type IndexedPropertyKeys<T extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T> : T extends TUnion<infer S> ? FromUnion<S> : T extends TLiteral<infer S> ? FromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
 ]);
-export declare function IndexedKeyResolve<T extends TSchema>(T: T): IndexedKeyResolve<T>;
+export declare function IndexedPropertyKeys<T extends TSchema>(T: T): IndexedPropertyKeys<T>;
 export {};

package/build/require/type/indexed/{indexed-key.js → indexed-property-keys.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexedKeyResolve = void 0;
+exports.IndexedPropertyKeys = void 0;
 const index_1 = require("../template-literal/index");
 const type_1 = require("../guard/type");
 function FromTemplateLiteral(T) {
@@ -16,13 +16,13 @@ function FromTemplateLiteral(T) {
 function FromUnion(T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [...IndexedKeyResolve(L), ...FromUnion(R)]
+        ? [...IndexedPropertyKeys(L), ...FromUnion(R)]
         : []);
 }
 function FromLiteral(T) {
     return ([T.toString()]);
 }
-function IndexedKeyResolve(T) {
+function IndexedPropertyKeys(T) {
     return [...new Set(((0, type_1.TTemplateLiteral)(T) ? FromTemplateLiteral(T) :
             (0, type_1.TUnion)(T) ? FromUnion(T.anyOf) :
                 (0, type_1.TLiteral)(T) ? FromLiteral(T.const) :
@@ -30,4 +30,4 @@ function IndexedKeyResolve(T) {
                         (0, type_1.TInteger)(T) ? ['[number]'] :
                             []))];
 }
-exports.IndexedKeyResolve = IndexedKeyResolve;
+exports.IndexedPropertyKeys = IndexedPropertyKeys;

package/build/require/type/indexed/indexed-type.d.ts

@@ -28,6 +28,6 @@ type FromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<i
 declare function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromKey<T, K>;
 type FromKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? [FromKey<T, L>, ...FromKeys<T, R>] : []);
 declare function FromKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromKeys<T, K>;
-export type IndexedTypeResolve<T extends TSchema, K extends PropertyKey[]> = (UnionResolve<FromKeys<T, K>>);
-export declare function IndexedTypeResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): IndexedTypeResolve<T, K>;
+export type IndexedType<T extends TSchema, K extends PropertyKey[]> = (UnionResolve<FromKeys<T, K>>);
+export declare function IndexedType<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): IndexedType<T, K>;
 export {};

package/build/require/type/indexed/indexed-type.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexedTypeResolve = void 0;
+exports.IndexedType = void 0;
 const index_1 = require("../never/index");
 const index_2 = require("../intersect/index");
 const index_3 = require("../union/index");
@@ -62,7 +62,7 @@ function FromKeys(T, K) {
         ? [FromKey(T, L), ...FromKeys(T, R)]
         : []);
 }
-function IndexedTypeResolve(T, K) {
+function IndexedType(T, K) {
     return ((0, index_3.UnionResolve)(FromKeys(T, K)));
 }
-exports.IndexedTypeResolve = IndexedTypeResolve;
+exports.IndexedType = IndexedType;

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

@@ -1,6 +1,9 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
-import { IndexedTypeResolve } from './indexed-type';
-import { IndexedKeyResolve } from './indexed-key';
-export type TIndex<T extends TSchema, K extends PropertyKey[]> = IndexedTypeResolve<T, K>;
-export declare function Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
+import { IndexedType } from './indexed-type';
+import { IndexedPropertyKeys } from './indexed-property-keys';
+import { type TMappedIndex } from './indexed-mapped';
+import { TMappedKey } from '../mapped/index';
+export type TIndex<T extends TSchema, K extends PropertyKey[]> = IndexedType<T, K>;
+export declare function Index<T extends TSchema, K extends TMappedKey>(T: T, K: K): TMappedIndex<T, K>;
+export declare function Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
 export declare function Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;

package/build/require/type/indexed/indexed.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Index = void 0;
+const type_1 = require("../guard/type");
 const indexed_type_1 = require("./indexed-type");
-const indexed_key_1 = require("./indexed-key");
-const type_1 = require("../clone/type");
-const type_2 = require("../guard/type");
+const indexed_property_keys_1 = require("./indexed-property-keys");
+const indexed_mapped_1 = require("./indexed-mapped");
+const type_2 = require("../clone/type");
 function Index(T, K, options = {}) {
-    const keys = (0, type_2.TSchema)(K) ? (0, indexed_key_1.IndexedKeyResolve)(K) : K;
-    const type = (0, indexed_type_1.IndexedTypeResolve)(T, keys);
-    return (0, type_1.CloneType)(type, options);
+    return ((0, type_1.TMappedKey)(K) ? (0, type_2.CloneType)((0, indexed_mapped_1.MappedIndex)(T, K), options) :
+        (0, type_1.TSchema)(K) ? (0, type_2.CloneType)((0, indexed_type_1.IndexedType)(T, (0, indexed_property_keys_1.IndexedPropertyKeys)(K)), options) :
+            (0, type_2.CloneType)((0, indexed_type_1.IndexedType)(T, K), options));
 }
 exports.Index = Index;

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

@@ -1,3 +1,2 @@
-export * from './keyof-string';
-export * from './keyof-type';
+export * from './keyof-property-keys';
 export * from './keyof';

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

@@ -14,6 +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("./keyof-string"), exports);
-__exportStar(require("./keyof-type"), exports);
+__exportStar(require("./keyof-property-keys"), exports);
 __exportStar(require("./keyof"), exports);

package/build/require/type/keyof/{keyof-string.d.ts → keyof-property-keys.d.ts}

@@ -7,7 +7,7 @@ import type { TTuple } from '../tuple/index';
 import type { TArray } from '../array/index';
 import type { TObject, TProperties } from '../object/index';
 import { OperatorUnionMany, OperatorIntersectMany } from '../operators/index';
-type FromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [KeyOfStringResolve<L>, ...FromRest<R>] : []);
+type FromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [KeyOfPropertyKeys<L>, ...FromRest<R>] : []);
 declare function FromRest<T extends TSchema[]>(T: [...T]): FromRest<T>;
 type FromIntersect<T extends TSchema[], C extends PropertyKey[][] = FromRest<T>> = (OperatorUnionMany<C>);
 declare function FromIntersect<T extends TSchema[]>(T: [...T], C?: FromRest<T>): FromIntersect<T>;
@@ -21,8 +21,8 @@ type FromArray<_ extends TSchema> = ([
 declare function FromArray<_ extends TSchema>(_: _): FromArray<_>;
 type FromProperties<T extends TProperties> = (UnionToTuple<keyof T>);
 declare function FromProperties<T extends TProperties>(T: T): FromProperties<T>;
-export type KeyOfStringResolve<T extends TSchema> = (T extends TRecursive<infer S> ? KeyOfStringResolve<S> : T extends TIntersect<infer S> ? FromIntersect<S> : T extends TUnion<infer S> ? FromUnion<S> : T extends TTuple<infer S> ? FromTuple<S> : T extends TArray<infer S> ? FromArray<S> : T extends TObject<infer S> ? FromProperties<S> : [
+export type KeyOfPropertyKeys<T extends TSchema> = (T extends TRecursive<infer S> ? KeyOfPropertyKeys<S> : T extends TIntersect<infer S> ? FromIntersect<S> : T extends TUnion<infer S> ? FromUnion<S> : T extends TTuple<infer S> ? FromTuple<S> : T extends TArray<infer S> ? FromArray<S> : T extends TObject<infer S> ? FromProperties<S> : [
 ]);
-export declare function KeyOfStringResolve<T extends TSchema>(T: T): KeyOfStringResolve<T>;
-export declare function KeyOfStringResolvePattern(schema: TSchema): string;
+export declare function KeyOfPropertyKeys<T extends TSchema>(T: T): KeyOfPropertyKeys<T>;
+export declare function KeyOfPattern(schema: TSchema): string;
 export {};