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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+import type { TSchema } from '../schema/index';
+import { Kind } from '../symbols/index';
+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/require/type/mapped/mapped-key.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappedKey = void 0;
+const index_1 = require("../symbols/index");
+function MappedKey(T) {
+    return {
+        [index_1.Kind]: 'MappedKey',
+        keys: T
+    };
+}
+exports.MappedKey = MappedKey;

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

@@ -0,0 +1,9 @@
+import type { TSchema } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { Kind } from '../symbols/index';
+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>;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappedResult = void 0;
+const index_1 = require("../symbols/index");
+function MappedResult(properties) {
+    return {
+        [index_1.Kind]: 'MappedResult',
+        properties
+    };
+}
+exports.MappedResult = MappedResult;

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

@@ -1,50 +1,43 @@
 import type { TSchema } from '../schema/index';
-import type { Ensure, Evaluate } from '../helpers/index';
-import { IndexedPropertyKeys } from '../indexed/index';
-import { Kind } from '../symbols/index';
+import type { Ensure, Evaluate, Assert } from '../helpers/index';
 import { type TArray } from '../array/index';
 import { type TAsyncIterator } from '../async-iterator/index';
 import { type TConstructor } from '../constructor/index';
 import { type TFunction } from '../function/index';
+import { type TIndexPropertyKeys } from '../indexed/index';
 import { type TIntersect } from '../intersect/index';
 import { type TIterator } from '../iterator/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
-import { type TNever } from '../never/index';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
 import { type TOptional } from '../optional/index';
 import { type TPromise } from '../promise/index';
 import { type TReadonly } from '../readonly/index';
+import { type TTuple } from '../tuple/index';
 import { type TUnion } from '../union/index';
-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>;
-export type MappedFunction<K extends PropertyKey[], I = TMappedKey<K>> = (T: I) => TSchema;
-type FromMappedResult<K extends PropertyKey, P extends TProperties> = (K extends keyof P ? FromMappedPropertyKey<K, P[K]> : TNever);
+import { type TMappedResult } from './mapped-result';
+import type { TMappedKey } from './mapped-key';
+type FromMappedResult<K extends PropertyKey, P extends TProperties> = (K extends keyof P ? FromSchemaType<K, P[K]> : TMappedResult<P>);
 declare function FromMappedResult<K extends PropertyKey, P extends TProperties>(K: K, P: P): FromMappedResult<K, P>;
-type FromMappedKey<K extends PropertyKey, _ extends PropertyKey[]> = (K extends TLiteralValue ? TLiteral<K> : TLiteral<'never'>);
-declare function FromMappedKey<K extends PropertyKey, P extends PropertyKey[]>(K: K, _: [...P]): TLiteral<TLiteralValue>;
-type FromRest<K extends PropertyKey, T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromMappedPropertyKey<K, L>, ...FromRest<K, R>] : [];
+type MappedKeyToMappedResultProperties<K extends PropertyKey, P extends PropertyKey[]> = (P extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? {
+    [_ in L]: TLiteral<Assert<L, TLiteralValue>>;
+} & MappedKeyToMappedResultProperties<K, R> : {});
+declare function MappedKeyToMappedResultProperties<K extends PropertyKey, P extends PropertyKey[]>(K: K, P: [...P]): MappedKeyToMappedResultProperties<K, P>;
+type FromMappedKey<K extends PropertyKey, P extends PropertyKey[], R extends TProperties = MappedKeyToMappedResultProperties<K, P>> = (FromMappedResult<K, R>);
+declare function FromMappedKey<K extends PropertyKey, P extends PropertyKey[]>(K: K, P: [...P]): FromMappedResult<K, MappedKeyToMappedResultProperties<K, P>>;
+type FromRest<K extends PropertyKey, T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromSchemaType<K, L>, ...FromRest<K, R>] : [];
 declare function FromRest<K extends PropertyKey, T extends TSchema[]>(K: K, T: [...T]): FromRest<K, T>;
 type FromProperties<K extends PropertyKey, T extends TProperties, R extends TProperties = Evaluate<{
-    [K2 in keyof T]: FromMappedPropertyKey<K, T[K2]>;
+    [K2 in keyof T]: FromSchemaType<K, T[K2]>;
 }>> = R;
 declare function FromProperties<K extends PropertyKey, T extends TProperties>(K: K, T: T): FromProperties<K, T>;
-export type FromMappedPropertyKey<K extends PropertyKey, T extends TSchema> = (T extends TReadonly<infer S> ? TReadonly<FromMappedPropertyKey<K, S>> : T extends TOptional<infer S> ? TOptional<FromMappedPropertyKey<K, S>> : T extends TMappedResult<infer P> ? FromMappedResult<K, P> : T extends TMappedKey<infer S> ? FromMappedKey<K, S> : T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<FromRest<K, S>, FromMappedPropertyKey<K, R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<FromRest<K, S>, FromMappedPropertyKey<K, R>> : T extends TAsyncIterator<infer S> ? TAsyncIterator<FromMappedPropertyKey<K, S>> : T extends TIterator<infer S> ? TIterator<FromMappedPropertyKey<K, S>> : T extends TIntersect<infer S> ? TIntersect<FromRest<K, S>> : T extends TUnion<infer S> ? TUnion<FromRest<K, S>> : T extends TObject<infer S> ? TObject<FromProperties<K, S>> : T extends TArray<infer S> ? TArray<FromMappedPropertyKey<K, S>> : T extends TPromise<infer S> ? TPromise<FromMappedPropertyKey<K, S>> : T);
-export declare function FromMappedPropertyKey<K extends PropertyKey, T extends TSchema>(K: K, T: T): FromMappedPropertyKey<K, T>;
-export type FromMappedPropertyKeys<K extends PropertyKey[], T extends TSchema> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? {
-    [_ in L]: FromMappedPropertyKey<L, T>;
-} & FromMappedPropertyKeys<R, T> : {});
-export declare function FromMappedPropertyKeys<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T): FromMappedPropertyKeys<K, T>;
-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>;
-export type TMapped<K extends PropertyKey[], F extends MappedFunction<K>, R extends TProperties = Evaluate<FromMappedPropertyKeys<K, ReturnType<F>>>> = Ensure<TObject<R>>;
-export declare function Mapped<K extends TSchema, I extends PropertyKey[] = IndexedPropertyKeys<K>, F extends MappedFunction<I> = MappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
-export declare function Mapped<K extends PropertyKey[], F extends MappedFunction<K> = MappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
+type FromSchemaType<K extends PropertyKey, T extends TSchema> = (T extends TReadonly<infer S> ? TReadonly<FromSchemaType<K, S>> : T extends TOptional<infer S> ? TOptional<FromSchemaType<K, S>> : T extends TMappedResult<infer P> ? FromMappedResult<K, P> : T extends TMappedKey<infer P> ? FromMappedKey<K, P> : T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<FromRest<K, S>, FromSchemaType<K, R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<FromRest<K, S>, FromSchemaType<K, R>> : T extends TAsyncIterator<infer S> ? TAsyncIterator<FromSchemaType<K, S>> : T extends TIterator<infer S> ? TIterator<FromSchemaType<K, S>> : T extends TIntersect<infer S> ? TIntersect<FromRest<K, S>> : T extends TUnion<infer S> ? TUnion<FromRest<K, S>> : T extends TTuple<infer S> ? TTuple<FromRest<K, S>> : T extends TObject<infer S> ? TObject<FromProperties<K, S>> : T extends TArray<infer S> ? TArray<FromSchemaType<K, S>> : T extends TPromise<infer S> ? TPromise<FromSchemaType<K, S>> : T);
+declare function FromSchemaType<K extends PropertyKey, T extends TSchema>(K: K, T: T): FromSchemaType<K, T>;
+type FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? {
+    [_ in L]: FromSchemaType<L, T>;
+} & FromMappedFunctionReturnType<R, T> : {});
+declare function FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T): FromMappedFunctionReturnType<K, T>;
+export type TMappedFunction<K extends PropertyKey[], I = TMappedKey<K>> = (T: I) => TSchema;
+export type TMapped<K extends PropertyKey[], F extends TMappedFunction<K>, R extends TProperties = Evaluate<FromMappedFunctionReturnType<K, ReturnType<F>>>> = Ensure<TObject<R>>;
+export declare function Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
+export declare function Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
 export {};