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

package/build/import/index.d.mts

@@ -21,25 +21,25 @@ export { Extends, type TExtends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCh
 export { Extract, type TExtract } from './type/extract/index.mjs';
 export { Function, type TFunction } from './type/function/index.mjs';
 export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index.mjs';
-export { Index, type TIndex, type TMappedIndex, IndexedPropertyKeys, IndexedType, MappedIndex } from './type/indexed/index.mjs';
+export { Index, IndexPropertyKeys, IndexMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexMappedResult } from './type/indexed/index.mjs';
 export { InstanceType, type TInstanceType } from './type/instance-type/index.mjs';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index.mjs';
 export { Intersect, type TIntersect, type IntersectOptions } from './type/intersect/index.mjs';
 export { Iterator, type TIterator } from './type/iterator/index.mjs';
-export { Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase, IntrinsicResolve } from './type/intrinsic/index.mjs';
+export { Intrinsic, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index.mjs';
 export { KeyOf, type TKeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index.mjs';
 export { Literal, type TLiteral } from './type/literal/index.mjs';
-export { Mapped, type MappedKey as TMappedKey, type MappedFunction, type TMapped as TMappedResult } from './type/mapped/index.mjs';
+export { Mapped, MappedKey, MappedResult, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction } from './type/mapped/index.mjs';
 export { Never, type TNever } from './type/never/index.mjs';
 export { Not, type TNot } from './type/not/index.mjs';
 export { Null, type TNull } from './type/null/index.mjs';
 export { Number, type TNumber, type NumberOptions } from './type/number/index.mjs';
 export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index.mjs';
-export { Omit, type TOmit } from './type/omit/index.mjs';
+export { Omit, type TOmit, type TOmitMappedResult } from './type/omit/index.mjs';
 export { Optional, type TOptional } from './type/optional/index.mjs';
 export { Parameters, type TParameters } from './type/parameters/index.mjs';
 export { Partial, type TPartial } from './type/partial/index.mjs';
-export { Pick, type TPick } from './type/pick/index.mjs';
+export { Pick, type TPick, type TPickMappedResult } from './type/pick/index.mjs';
 export { Promise, type TPromise } from './type/promise/index.mjs';
 export { Readonly, type TReadonly } from './type/readonly/index.mjs';
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index.mjs';

package/build/import/index.mjs

@@ -21,15 +21,15 @@ export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './t
 export { Extract } from './type/extract/index.mjs';
 export { Function } from './type/function/index.mjs';
 export { Increment } from './type/helpers/index.mjs';
-export { Index, IndexedPropertyKeys, IndexedType, MappedIndex } from './type/indexed/index.mjs';
+export { Index, IndexPropertyKeys, IndexMappedResult } from './type/indexed/index.mjs';
 export { InstanceType } from './type/instance-type/index.mjs';
 export { Integer } from './type/integer/index.mjs';
 export { Intersect } from './type/intersect/index.mjs';
 export { Iterator } from './type/iterator/index.mjs';
-export { Capitalize, Lowercase, Uncapitalize, Uppercase, IntrinsicResolve } from './type/intrinsic/index.mjs';
+export { Intrinsic, Capitalize, Lowercase, Uncapitalize, Uppercase } from './type/intrinsic/index.mjs';
 export { KeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index.mjs';
 export { Literal } from './type/literal/index.mjs';
-export { Mapped } from './type/mapped/index.mjs';
+export { Mapped, MappedKey, MappedResult } from './type/mapped/index.mjs';
 export { Never } from './type/never/index.mjs';
 export { Not } from './type/not/index.mjs';
 export { Null } from './type/null/index.mjs';

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

@@ -1,10 +1,10 @@
 import type { UnionToTuple, Assert, Evaluate } from '../helpers/index.mjs';
 import { type TObject, type ObjectOptions } from '../object/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
-import { IndexedType } from '../indexed/index.mjs';
+import { type TIndex } from '../indexed/index.mjs';
 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/import/type/extends/extends-mapped-result-from-result.d.mts

@@ -0,0 +1,13 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TExtends } from './extends.mjs';
+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/import/type/extends/extends-mapped-result-from-result.mjs

@@ -0,0 +1,14 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Extends } from './extends.mjs';
+function MappedResultExtendsPropertyKeys(K, U, L, R) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Extends(K[K2], U, L, R) };
+    }, {});
+}
+function MappedResultExtendsProperties(K, U, L, R) {
+    return MappedResultExtendsPropertyKeys(K.properties, U, L, R);
+}
+export function ExtendsMappedResultFromResult(T, U, L, R) {
+    const P = MappedResultExtendsProperties(T, U, L, R);
+    return MappedResult(P);
+}

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

@@ -1,13 +1,17 @@
 import type { TSchema } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
-import { type TMappedResult } from '../mapped/index.mjs';
+import type { Assert } from '../helpers/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { TLiteral, TLiteralValue } from '../literal/index.mjs';
 import { type TExtends } from './extends.mjs';
-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/import/type/extends/extends-mapped-result.mjs

@@ -1,14 +1,21 @@
 import { MappedResult } from '../mapped/index.mjs';
+import { Literal } from '../literal/index.mjs';
 import { Extends } from './extends.mjs';
-function MappedResultExtendsPropertyKeys(K, U, L, R) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Extends(K[K2], U, L, R) };
-    }, {});
+function MappedExtendsPropertyKey(K, U, L, R) {
+    return {
+        [K]: Extends(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) }
+        : {});
 }
-export 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);
+}
+export function ExtendsMappedResult(T, U, L, R) {
+    const P = MappedExtendsProperties(T, U, L, R);
     return MappedResult(P);
 }

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

@@ -3,12 +3,12 @@ import type { Static } from '../static/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { TMappedKey, TMappedResult } from '../mapped/index.mjs';
 import { UnionToTuple } from '../helpers/index.mjs';
-import { MappedExtends } from './extends-mapped.mjs';
-import { MappedResultExtends } from './extends-mapped-result.mjs';
+import { type TExtendsMappedResult } from './extends-mapped-result.mjs';
+import { type TExtendsMappedResultFromResult } from './extends-mapped-result-from-result.mjs';
 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/import/type/extends/extends.mjs

@@ -2,8 +2,8 @@ import { TMappedKey as IsMappedKeyType, TMappedResult as IsMappedResultType } fr
 import { Union } from '../union/index.mjs';
 import { ExtendsCheck, ExtendsResult } from './extends-check.mjs';
 import { CloneType } from '../clone/type.mjs';
-import { MappedExtends } from './extends-mapped.mjs';
-import { MappedResultExtends } from './extends-mapped-result.mjs';
+import { ExtendsMappedResult } from './extends-mapped-result.mjs';
+import { ExtendsMappedResultFromResult } from './extends-mapped-result-from-result.mjs';
 function ExtendsResolve(left, right, trueType, falseType) {
     const R = ExtendsCheck(left, right);
     return (R === ExtendsResult.Union ? Union([trueType, falseType]) :
@@ -11,7 +11,7 @@ function ExtendsResolve(left, right, trueType, falseType) {
             falseType);
 }
 export function Extends(L, R, T, F, options = {}) {
-    return (IsMappedResultType(L) ? CloneType(MappedResultExtends(L, R, T, F), options) :
-        IsMappedKeyType(L) ? CloneType(MappedExtends(L, R, T, F), options) :
+    return (IsMappedResultType(L) ? CloneType(ExtendsMappedResultFromResult(L, R, T, F), options) :
+        IsMappedKeyType(L) ? CloneType(ExtendsMappedResult(L, R, T, F), options) :
             CloneType(ExtendsResolve(L, R, T, F), options));
 }

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

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

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

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

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

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

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

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

package/build/import/type/indexed/{indexed-mapped.d.mts → indexed-mapped-result.d.mts}

@@ -1,16 +1,16 @@
 import { type TSchema } from '../schema/index.mjs';
 import { type TProperties } from '../object/index.mjs';
-import { IndexedType } from './indexed-type.mjs';
+import { type TIndexResult } from './indexed-result.mjs';
 import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
 import { Evaluate } from '../helpers/index.mjs';
 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/import/type/indexed/{indexed-mapped.mjs → indexed-mapped-result.mjs}

@@ -1,7 +1,7 @@
-import { IndexedType } from './indexed-type.mjs';
+import { IndexResult } from './indexed-result.mjs';
 import { MappedResult } from '../mapped/index.mjs';
 function MappedIndexPropertyKey(T, K) {
-    return { [K]: IndexedType(T, [K]) };
+    return { [K]: IndexResult(T, [K]) };
 }
 function MappedIndexPropertyKeys(T, K) {
     const [L, ...R] = K;
@@ -12,7 +12,7 @@ function MappedIndexPropertyKeys(T, K) {
 function MappedIndexProperties(T, K) {
     return MappedIndexPropertyKeys(T, K.keys);
 }
-export function MappedIndex(T, K) {
+export function IndexMappedResult(T, K) {
     const P = MappedIndexProperties(T, K);
     return MappedResult(P);
 }

package/build/import/type/indexed/indexed-property-keys.d.mts

@@ -6,11 +6,11 @@ import { type TSchema } from '../schema/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 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/import/type/indexed/indexed-property-keys.mjs

@@ -13,13 +13,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()]);
 }
-export function IndexedPropertyKeys(T) {
+export function IndexPropertyKeys(T) {
     return [...new Set((IsTemplateLiteralType(T) ? FromTemplateLiteral(T) :
             IsUnionType(T) ? FromUnion(T.anyOf) :
                 IsLiteralType(T) ? FromLiteral(T.const) :

package/build/import/type/indexed/{indexed-type.d.mts → indexed-result.d.mts}

@@ -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/import/type/indexed/{indexed-type.mjs → indexed-result.mjs}

@@ -59,6 +59,6 @@ function FromKeys(T, K) {
         ? [FromKey(T, L), ...FromKeys(T, R)]
         : []);
 }
-export function IndexedType(T, K) {
+export function IndexResult(T, K) {
     return (UnionResolve(FromKeys(T, K)));
 }

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

@@ -1,9 +1,9 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import { IndexedType } from './indexed-type.mjs';
-import { IndexedPropertyKeys } from './indexed-property-keys.mjs';
-import { type TMappedIndex } from './indexed-mapped.mjs';
+import { type TIndexResult } from './indexed-result.mjs';
+import { type TIndexPropertyKeys } from './indexed-property-keys.mjs';
+import { type TIndexMappedResult } from './indexed-mapped-result.mjs';
 import { TMappedKey } from '../mapped/index.mjs';
-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/import/type/indexed/indexed.mjs

@@ -1,10 +1,10 @@
 import { TSchema as IsSchemaType, TMappedKey as IsMappedKey } from '../guard/type.mjs';
-import { IndexedType } from './indexed-type.mjs';
-import { IndexedPropertyKeys } from './indexed-property-keys.mjs';
-import { MappedIndex } from './indexed-mapped.mjs';
+import { IndexResult } from './indexed-result.mjs';
+import { IndexPropertyKeys } from './indexed-property-keys.mjs';
+import { IndexMappedResult } from './indexed-mapped-result.mjs';
 import { CloneType } from '../clone/type.mjs';
 export function Index(T, K, options = {}) {
-    return (IsMappedKey(K) ? CloneType(MappedIndex(T, K), options) :
-        IsSchemaType(K) ? CloneType(IndexedType(T, IndexedPropertyKeys(K)), options) :
-            CloneType(IndexedType(T, K), options));
+    return (IsMappedKey(K) ? CloneType(IndexMappedResult(T, K), options) :
+        IsSchemaType(K) ? CloneType(IndexResult(T, IndexPropertyKeys(K)), options) :
+            CloneType(IndexResult(T, K), options));
 }

package/build/import/type/intrinsic/capitalize.d.mts

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

package/build/import/type/intrinsic/capitalize.mjs

@@ -0,0 +1,5 @@
+import { Intrinsic } from './intrinsic.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Capitalize(T, options = {}) {
+    return CloneType(Intrinsic(T, 'Capitalize'), options);
+}

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { type TIntrinsic, type IntrinsicMode } from './intrinsic.mjs';
+import { TLiteral, TLiteralValue } from '../literal/index.mjs';
+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/import/type/intrinsic/intrinsic-mapped-result.mjs

@@ -0,0 +1,21 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Intrinsic } from './intrinsic.mjs';
+import { Literal } from '../literal/index.mjs';
+function MappedIntrinsicPropertyKey(K, M) {
+    return {
+        [K]: Intrinsic(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);
+}
+export function IntrinsicMappedResult(T, M) {
+    const P = MappedIntrinsicProperties(T, M);
+    return MappedResult(P);
+}

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

@@ -1,22 +1,17 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
 import { type TTemplateLiteral, type TTemplateLiteralKind } from '../template-literal/index.mjs';
+import { type TIntrinsicMappedResult } from './intrinsic-mapped-result.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TUnion } from '../union/index.mjs';
-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.mjs';
+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/import/type/intrinsic/intrinsic.mjs

@@ -1,8 +1,8 @@
 import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralGenerate } from '../template-literal/index.mjs';
+import { IntrinsicMappedResult } from './intrinsic-mapped-result.mjs';
 import { Literal } from '../literal/index.mjs';
 import { Union } from '../union/index.mjs';
-import { TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType } from '../guard/type.mjs';
-import { CloneType } from '../clone/type.mjs';
+import { TMappedKey as IsMappedKeyType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType } from '../guard/type.mjs';
 function ApplyUncapitalize(value) {
     const [first, rest] = [value.slice(0, 1), value.slice(1)];
     return [first.toLowerCase(), rest].join('');
@@ -37,23 +37,12 @@ function FromLiteralValue(value, mode) {
 }
 function FromRest(T, mode) {
     const [L, ...R] = T;
-    return (T.length > 0 ? [IntrinsicResolve(L, mode), ...FromRest(R, mode)] : []);
-}
-export function IntrinsicResolve(schema, mode) {
-    return (IsTemplateLiteralType(schema) ? FromTemplateLiteral(schema, mode) :
-        IsUnionType(schema) ? Union(FromRest(schema.anyOf, mode)) :
-            IsLiteralType(schema) ? Literal(FromLiteralValue(schema.const, mode)) :
-                schema);
-}
-export function Uncapitalize(T, options = {}) {
-    return CloneType(IntrinsicResolve(T, 'Uncapitalize'), options);
-}
-export function Uppercase(T, options = {}) {
-    return CloneType(IntrinsicResolve(T, 'Uppercase'), options);
-}
-export function Lowercase(T, options = {}) {
-    return CloneType(IntrinsicResolve(T, 'Lowercase'), options);
-}
-export function Capitalize(T, options = {}) {
-    return CloneType(IntrinsicResolve(T, 'Capitalize'), options);
+    return (T.length > 0 ? [Intrinsic(L, mode), ...FromRest(R, mode)] : []);
+}
+export function Intrinsic(schema, mode) {
+    return (IsMappedKeyType(schema) ? IntrinsicMappedResult(schema, mode) :
+        IsTemplateLiteralType(schema) ? FromTemplateLiteral(schema, mode) :
+            IsUnionType(schema) ? Union(FromRest(schema.anyOf, mode)) :
+                IsLiteralType(schema) ? Literal(FromLiteralValue(schema.const, mode)) :
+                    schema);
 }

package/build/import/type/intrinsic/lowercase.d.mts

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

package/build/import/type/intrinsic/lowercase.mjs

@@ -0,0 +1,5 @@
+import { Intrinsic } from './intrinsic.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Lowercase(T, options = {}) {
+    return CloneType(Intrinsic(T, 'Lowercase'), options);
+}

package/build/import/type/intrinsic/uncapitalize.d.mts

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

package/build/import/type/intrinsic/uncapitalize.mjs

@@ -0,0 +1,5 @@
+import { Intrinsic } from './intrinsic.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Uncapitalize(T, options = {}) {
+    return CloneType(Intrinsic(T, 'Uncapitalize'), options);
+}

package/build/import/type/intrinsic/uppercase.d.mts

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

package/build/import/type/intrinsic/uppercase.mjs

@@ -0,0 +1,5 @@
+import { Intrinsic } from './intrinsic.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Uppercase(T, options = {}) {
+    return CloneType(Intrinsic(T, 'Uppercase'), options);
+}

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

@@ -1 +1,3 @@
+export * from './mapped-key.mjs';
+export * from './mapped-result.mjs';
 export * from './mapped.mjs';

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

@@ -1 +1,3 @@
+export * from './mapped-key.mjs';
+export * from './mapped-result.mjs';
 export * from './mapped.mjs';

package/build/import/type/mapped/mapped-key.d.mts

@@ -0,0 +1,8 @@
+import type { TSchema } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TMappedKey<T extends PropertyKey[] = PropertyKey[]> extends TSchema {
+    [Kind]: 'MappedKey';
+    static: T[number];
+    keys: T;
+}
+export declare function MappedKey<T extends PropertyKey[]>(T: [...T]): TMappedKey<T>;

package/build/import/type/mapped/mapped-key.mjs

@@ -0,0 +1,7 @@
+import { Kind } from '../symbols/index.mjs';
+export function MappedKey(T) {
+    return {
+        [Kind]: 'MappedKey',
+        keys: T
+    };
+}

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

@@ -0,0 +1,9 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TMappedResult<T extends TProperties = TProperties> extends TSchema {
+    [Kind]: 'MappedResult';
+    properties: T;
+    static: unknown;
+}
+export declare function MappedResult<T extends TProperties>(properties: T): TMappedResult<T>;