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

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);

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

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

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

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

package/build/require/type/indexed/{indexed-mapped.d.ts → indexed-mapped-result.d.ts}

@@ -1,16 +1,16 @@
 import { type TSchema } from '../schema/index';
 import { type TProperties } from '../object/index';
-import { IndexedType } from './indexed-type';
+import { type TIndexResult } from './indexed-result';
 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]>;
+    [_ in K]: TIndexResult<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 type TIndexMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedIndexProperties<T, K>> = (TMappedResult<P>);
+export declare function IndexMappedResult<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 → indexed-mapped-result.js}

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

package/build/require/type/indexed/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[]] ? [...IndexedPropertyKeys<L>, ...FromUnion<R>] : []);
+type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...TIndexPropertyKeys<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 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 type TIndexPropertyKeys<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 IndexedPropertyKeys<T extends TSchema>(T: T): IndexedPropertyKeys<T>;
+export declare function IndexPropertyKeys<T extends TSchema>(T: T): TIndexPropertyKeys<T>;
 export {};

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexedPropertyKeys = void 0;
+exports.IndexPropertyKeys = 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
-        ? [...IndexedPropertyKeys(L), ...FromUnion(R)]
+        ? [...IndexPropertyKeys(L), ...FromUnion(R)]
         : []);
 }
 function FromLiteral(T) {
     return ([T.toString()]);
 }
-function IndexedPropertyKeys(T) {
+function IndexPropertyKeys(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 IndexedPropertyKeys(T) {
                         (0, type_1.TInteger)(T) ? ['[number]'] :
                             []))];
 }
-exports.IndexedPropertyKeys = IndexedPropertyKeys;
+exports.IndexPropertyKeys = IndexPropertyKeys;

package/build/require/type/indexed/{indexed-type.d.ts → indexed-result.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 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 type TIndexResult<T extends TSchema, K extends PropertyKey[]> = (UnionResolve<FromKeys<T, K>>);
+export declare function IndexResult<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TIndexResult<T, K>;
 export {};

package/build/require/type/indexed/{indexed-type.js → indexed-result.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexedType = void 0;
+exports.IndexResult = 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 IndexedType(T, K) {
+function IndexResult(T, K) {
     return ((0, index_3.UnionResolve)(FromKeys(T, K)));
 }
-exports.IndexedType = IndexedType;
+exports.IndexResult = IndexResult;

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

@@ -1,9 +1,9 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
-import { IndexedType } from './indexed-type';
-import { IndexedPropertyKeys } from './indexed-property-keys';
-import { type TMappedIndex } from './indexed-mapped';
+import { type TIndexResult } from './indexed-result';
+import { type TIndexPropertyKeys } from './indexed-property-keys';
+import { type TIndexMappedResult } from './indexed-mapped-result';
 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 type TIndex<T extends TSchema, K extends PropertyKey[]> = TIndexResult<T, K>;
+export declare function Index<T extends TSchema, K extends TMappedKey>(T: T, K: K): TIndexMappedResult<T, K>;
+export declare function Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<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

@@ -2,13 +2,13 @@
 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_result_1 = require("./indexed-result");
 const indexed_property_keys_1 = require("./indexed-property-keys");
-const indexed_mapped_1 = require("./indexed-mapped");
+const indexed_mapped_result_1 = require("./indexed-mapped-result");
 const type_2 = require("../clone/type");
 function Index(T, K, 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));
+    return ((0, type_1.TMappedKey)(K) ? (0, type_2.CloneType)((0, indexed_mapped_result_1.IndexMappedResult)(T, K), options) :
+        (0, type_1.TSchema)(K) ? (0, type_2.CloneType)((0, indexed_result_1.IndexResult)(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K)), options) :
+            (0, type_2.CloneType)((0, indexed_result_1.IndexResult)(T, K), options));
 }
 exports.Index = Index;

package/build/require/type/intrinsic/capitalize.d.ts

@@ -0,0 +1,4 @@
+import { TSchema, SchemaOptions } from '../schema/index';
+import { TIntrinsic } from './intrinsic';
+export type TCapitalize<T extends TSchema> = TIntrinsic<T, 'Capitalize'>;
+export declare function Capitalize<T extends TSchema>(T: T, options?: SchemaOptions): TCapitalize<T>;

package/build/require/type/intrinsic/capitalize.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Capitalize = void 0;
+const intrinsic_1 = require("./intrinsic");
+const type_1 = require("../clone/type");
+function Capitalize(T, options = {}) {
+    return (0, type_1.CloneType)((0, intrinsic_1.Intrinsic)(T, 'Capitalize'), options);
+}
+exports.Capitalize = Capitalize;

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

@@ -1 +1,6 @@
+export * from './capitalize';
+export * from './intrinsic-mapped-result';
 export * from './intrinsic';
+export * from './lowercase';
+export * from './uncapitalize';
+export * from './uppercase';

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

@@ -14,4 +14,9 @@ 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("./capitalize"), exports);
+__exportStar(require("./intrinsic-mapped-result"), exports);
 __exportStar(require("./intrinsic"), exports);
+__exportStar(require("./lowercase"), exports);
+__exportStar(require("./uncapitalize"), exports);
+__exportStar(require("./uppercase"), exports);

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

@@ -0,0 +1,15 @@
+import type { TProperties } from '../object/index';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+import { type TIntrinsic, type IntrinsicMode } from './intrinsic';
+import { TLiteral, TLiteralValue } from '../literal/index';
+type MappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode, P extends TLiteralValue = K extends TLiteralValue ? K : never> = {
+    [_ in K]: TIntrinsic<TLiteral<P>, M>;
+};
+declare function MappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode>(K: K, M: M): MappedIntrinsicPropertyKey<K, M>;
+type MappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? MappedIntrinsicPropertyKey<L, M> & MappedIntrinsicPropertyKeys<R, M> : {});
+declare function MappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode>(K: [...K], M: M): MappedIntrinsicPropertyKeys<K, M>;
+type MappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode> = (MappedIntrinsicPropertyKeys<K['keys'], M>);
+declare function MappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode>(T: K, M: M): MappedIntrinsicProperties<K, M>;
+export type TIntrinsicMappedResult<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = MappedIntrinsicProperties<K, M>> = (TMappedResult<P>);
+export declare function IntrinsicMappedResult<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = MappedIntrinsicProperties<K, M>>(T: K, M: M): TMappedResult<P>;
+export {};

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntrinsicMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const intrinsic_1 = require("./intrinsic");
+const index_2 = require("../literal/index");
+function MappedIntrinsicPropertyKey(K, M) {
+    return {
+        [K]: (0, intrinsic_1.Intrinsic)((0, index_2.Literal)(K), M)
+    };
+}
+function MappedIntrinsicPropertyKeys(K, M) {
+    const [L, ...R] = K;
+    return (K.length > 0
+        ? { ...MappedIntrinsicPropertyKey(L, M), ...MappedIntrinsicPropertyKeys(R, M) }
+        : {});
+}
+function MappedIntrinsicProperties(T, M) {
+    return MappedIntrinsicPropertyKeys(T['keys'], M);
+}
+function IntrinsicMappedResult(T, M) {
+    const P = MappedIntrinsicProperties(T, M);
+    return (0, index_1.MappedResult)(P);
+}
+exports.IntrinsicMappedResult = IntrinsicMappedResult;

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

@@ -1,22 +1,17 @@
-import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TSchema } from '../schema/index';
 import { type TTemplateLiteral, type TTemplateLiteralKind } from '../template-literal/index';
+import { type TIntrinsicMappedResult } from './intrinsic-mapped-result';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TUnion } from '../union/index';
-type IntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize';
-type FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode> = M extends IntrinsicMode ? T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? [IntrinsicResolve<L, M>, ...FromTemplateLiteral<R, M>] : T : T;
+import { type TMappedKey } from '../mapped/index';
+export type IntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize';
+type FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode> = M extends IntrinsicMode ? T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? [TIntrinsic<L, M>, ...FromTemplateLiteral<R, M>] : T : T;
 declare function FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode>(schema: TTemplateLiteral, mode: IntrinsicMode): FromTemplateLiteral<T, M>;
 type FromLiteralValue<T, M extends IntrinsicMode> = (T extends string ? M extends 'Uncapitalize' ? Uncapitalize<T> : M extends 'Capitalize' ? Capitalize<T> : M extends 'Uppercase' ? Uppercase<T> : M extends 'Lowercase' ? Lowercase<T> : string : T);
 declare function FromLiteralValue(value: TLiteralValue, mode: IntrinsicMode): string;
-type FromRest<T extends TSchema[], M extends IntrinsicMode> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [IntrinsicResolve<L, M>, ...FromRest<R, M>] : [];
+type FromRest<T extends TSchema[], M extends IntrinsicMode> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [TIntrinsic<L, M>, ...FromRest<R, M>] : [];
 declare function FromRest<T extends TSchema[], M extends IntrinsicMode>(T: [...T], mode: M): FromRest<T, M>;
-export type IntrinsicResolve<T extends TSchema, M extends IntrinsicMode> = T extends TTemplateLiteral<infer S> ? TTemplateLiteral<FromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<FromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<FromLiteralValue<S, M>> : T;
-export declare function IntrinsicResolve<T extends TSchema, M extends IntrinsicMode>(schema: T, mode: M): IntrinsicResolve<T, M>;
-export type TUncapitalize<T extends TSchema> = IntrinsicResolve<T, 'Uncapitalize'>;
-export declare function Uncapitalize<T extends TSchema>(T: T, options?: SchemaOptions): TUncapitalize<T>;
-export type TUppercase<T extends TSchema> = IntrinsicResolve<T, 'Uppercase'>;
-export declare function Uppercase<T extends TSchema>(T: T, options?: SchemaOptions): TUppercase<T>;
-export type TLowercase<T extends TSchema> = IntrinsicResolve<T, 'Lowercase'>;
-export declare function Lowercase<T extends TSchema>(T: T, options?: SchemaOptions): TLowercase<T>;
-export type TCapitalize<T extends TSchema> = IntrinsicResolve<T, 'Capitalize'>;
-export declare function Capitalize<T extends TSchema>(T: T, options?: SchemaOptions): TCapitalize<T>;
+export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicMappedResult<T, M> : T extends TTemplateLiteral<infer S> ? TTemplateLiteral<FromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<FromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<FromLiteralValue<S, M>> : T;
+export declare function Intrinsic<T extends TMappedKey, M extends IntrinsicMode>(schema: T, mode: M): TIntrinsicMappedResult<T, M>;
+export declare function Intrinsic<T extends TSchema, M extends IntrinsicMode>(schema: T, mode: M): TIntrinsic<T, M>;
 export {};

package/build/require/type/intrinsic/intrinsic.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Capitalize = exports.Lowercase = exports.Uppercase = exports.Uncapitalize = exports.IntrinsicResolve = void 0;
+exports.Intrinsic = void 0;
 const index_1 = require("../template-literal/index");
+const intrinsic_mapped_result_1 = require("./intrinsic-mapped-result");
 const index_2 = require("../literal/index");
 const index_3 = require("../union/index");
 const type_1 = require("../guard/type");
-const type_2 = require("../clone/type");
 function ApplyUncapitalize(value) {
     const [first, rest] = [value.slice(0, 1), value.slice(1)];
     return [first.toLowerCase(), rest].join('');
@@ -40,28 +40,13 @@ function FromLiteralValue(value, mode) {
 }
 function FromRest(T, mode) {
     const [L, ...R] = T;
-    return (T.length > 0 ? [IntrinsicResolve(L, mode), ...FromRest(R, mode)] : []);
+    return (T.length > 0 ? [Intrinsic(L, mode), ...FromRest(R, mode)] : []);
 }
-function IntrinsicResolve(schema, mode) {
-    return ((0, type_1.TTemplateLiteral)(schema) ? FromTemplateLiteral(schema, mode) :
-        (0, type_1.TUnion)(schema) ? (0, index_3.Union)(FromRest(schema.anyOf, mode)) :
-            (0, type_1.TLiteral)(schema) ? (0, index_2.Literal)(FromLiteralValue(schema.const, mode)) :
-                schema);
+function Intrinsic(schema, mode) {
+    return ((0, type_1.TMappedKey)(schema) ? (0, intrinsic_mapped_result_1.IntrinsicMappedResult)(schema, mode) :
+        (0, type_1.TTemplateLiteral)(schema) ? FromTemplateLiteral(schema, mode) :
+            (0, type_1.TUnion)(schema) ? (0, index_3.Union)(FromRest(schema.anyOf, mode)) :
+                (0, type_1.TLiteral)(schema) ? (0, index_2.Literal)(FromLiteralValue(schema.const, mode)) :
+                    schema);
 }
-exports.IntrinsicResolve = IntrinsicResolve;
-function Uncapitalize(T, options = {}) {
-    return (0, type_2.CloneType)(IntrinsicResolve(T, 'Uncapitalize'), options);
-}
-exports.Uncapitalize = Uncapitalize;
-function Uppercase(T, options = {}) {
-    return (0, type_2.CloneType)(IntrinsicResolve(T, 'Uppercase'), options);
-}
-exports.Uppercase = Uppercase;
-function Lowercase(T, options = {}) {
-    return (0, type_2.CloneType)(IntrinsicResolve(T, 'Lowercase'), options);
-}
-exports.Lowercase = Lowercase;
-function Capitalize(T, options = {}) {
-    return (0, type_2.CloneType)(IntrinsicResolve(T, 'Capitalize'), options);
-}
-exports.Capitalize = Capitalize;
+exports.Intrinsic = Intrinsic;

package/build/require/type/intrinsic/lowercase.d.ts

@@ -0,0 +1,4 @@
+import { TSchema, SchemaOptions } from '../schema/index';
+import { TIntrinsic } from './intrinsic';
+export type TLowercase<T extends TSchema> = TIntrinsic<T, 'Lowercase'>;
+export declare function Lowercase<T extends TSchema>(T: T, options?: SchemaOptions): TLowercase<T>;

package/build/require/type/intrinsic/lowercase.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lowercase = void 0;
+const intrinsic_1 = require("./intrinsic");
+const type_1 = require("../clone/type");
+function Lowercase(T, options = {}) {
+    return (0, type_1.CloneType)((0, intrinsic_1.Intrinsic)(T, 'Lowercase'), options);
+}
+exports.Lowercase = Lowercase;

package/build/require/type/intrinsic/uncapitalize.d.ts

@@ -0,0 +1,4 @@
+import { TSchema, SchemaOptions } from '../schema/index';
+import { TIntrinsic } from './intrinsic';
+export type TUncapitalize<T extends TSchema> = TIntrinsic<T, 'Uncapitalize'>;
+export declare function Uncapitalize<T extends TSchema>(T: T, options?: SchemaOptions): TUncapitalize<T>;