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

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

@@ -1,4 +1,4 @@
-import { type TSchema } from '../schema/index';
+import type { TSchema, SchemaOptions } from '../schema/index';
 import { type TProperties } from '../object/index';
 import { type TIndexResult } from './indexed-result';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
@@ -6,11 +6,11 @@ import { Evaluate } from '../helpers/index';
 type MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
     [_ in K]: TIndexResult<T, [K]>;
 };
-declare function MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): MappedIndexPropertyKey<T, K>;
+declare function MappedIndexPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K, options: SchemaOptions): 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>;
+declare function MappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): 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 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>;
+declare function MappedIndexProperties<T extends TSchema, K extends TMappedKey>(T: T, K: K, options: SchemaOptions): MappedIndexProperties<T, K>;
+export type TIndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedIndexProperties<T, K>> = (TMappedResult<P>);
+export declare function IndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedIndexProperties<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
 export {};

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

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

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

@@ -1,4 +1,4 @@
-import { type TSchema } from '../schema/index';
+import { type TSchema, SchemaOptions } from '../schema/index';
 import { type TObject, type TProperties } from '../object/index';
 import { type TNever } from '../never/index';
 import { type TRecursive } from '../recursive/index';
@@ -29,5 +29,5 @@ declare function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: 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 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 declare function IndexResult<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): TIndexResult<T, K>;
 export {};

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

@@ -4,7 +4,8 @@ exports.IndexResult = void 0;
 const index_1 = require("../never/index");
 const index_2 = require("../intersect/index");
 const index_3 = require("../union/index");
-const type_1 = require("../guard/type");
+const type_1 = require("../clone/type");
+const type_2 = require("../guard/type");
 function FromRest(T, K) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -14,7 +15,7 @@ function FromRest(T, K) {
 function FromIntersectRest(T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? (0, type_1.TNever)(L)
+        ? (0, type_2.TNever)(L)
             ? [...FromIntersectRest(R)]
             : [L, ...FromIntersectRest(R)]
         : []);
@@ -25,7 +26,7 @@ function FromIntersect(T, K) {
 function FromUnionRest(T, S = T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? (0, type_1.TNever)(L)
+        ? (0, type_2.TNever)(L)
             ? []
             : FromUnionRest(R, S)
         : S);
@@ -49,11 +50,11 @@ function FromProperty(T, K) {
         : (0, index_1.Never)());
 }
 function FromKey(T, K) {
-    return ((0, type_1.TIntersect)(T) ? FromIntersect(T.allOf, K) :
-        (0, type_1.TUnion)(T) ? FromUnion(T.anyOf, K) :
-            (0, type_1.TTuple)(T) ? FromTuple(T.items ?? [], K) :
-                (0, type_1.TArray)(T) ? FromArray(T.items, K) :
-                    (0, type_1.TObject)(T) ? FromProperty(T.properties, K) :
+    return ((0, type_2.TIntersect)(T) ? FromIntersect(T.allOf, K) :
+        (0, type_2.TUnion)(T) ? FromUnion(T.anyOf, K) :
+            (0, type_2.TTuple)(T) ? FromTuple(T.items ?? [], K) :
+                (0, type_2.TArray)(T) ? FromArray(T.items, K) :
+                    (0, type_2.TObject)(T) ? FromProperty(T.properties, K) :
                         (0, index_1.Never)());
 }
 function FromKeys(T, K) {
@@ -62,7 +63,7 @@ function FromKeys(T, K) {
         ? [FromKey(T, L), ...FromKeys(T, R)]
         : []);
 }
-function IndexResult(T, K) {
-    return ((0, index_3.UnionResolve)(FromKeys(T, K)));
+function IndexResult(T, K, options) {
+    return ((0, type_1.CloneType)((0, index_3.UnionResolve)(FromKeys(T, K)), options));
 }
 exports.IndexResult = IndexResult;

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

@@ -1,9 +1,9 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import { type TIndexResult } from './indexed-result';
 import { type TIndexPropertyKeys } from './indexed-property-keys';
-import { type TIndexMappedResult } from './indexed-mapped-result';
+import { type TIndexFromMappedKey } from './indexed-from-mapped-key';
 import { TMappedKey } from '../mapped/index';
 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 TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<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

@@ -4,11 +4,11 @@ exports.Index = void 0;
 const type_1 = require("../guard/type");
 const indexed_result_1 = require("./indexed-result");
 const indexed_property_keys_1 = require("./indexed-property-keys");
-const indexed_mapped_result_1 = require("./indexed-mapped-result");
+const indexed_from_mapped_key_1 = require("./indexed-from-mapped-key");
 const type_2 = require("../clone/type");
 function Index(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));
+    return ((0, type_1.TMappedKey)(K) ? (0, type_2.CloneType)((0, indexed_from_mapped_key_1.IndexFromMappedKey)(T, K, options)) :
+        (0, type_1.TSchema)(K) ? (0, indexed_result_1.IndexResult)(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K), options) :
+            (0, indexed_result_1.IndexResult)(T, K, options));
 }
 exports.Index = Index;

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

@@ -2,8 +2,7 @@
 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);
+    return (0, intrinsic_1.Intrinsic)(T, 'Capitalize', options);
 }
 exports.Capitalize = Capitalize;

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

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

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

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

package/build/require/type/intrinsic/{intrinsic-mapped-result.d.ts → intrinsic-from-mapped-key.d.ts}

@@ -1,3 +1,4 @@
+import type { SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
 import { type TIntrinsic, type IntrinsicMode } from './intrinsic';
@@ -5,11 +6,11 @@ 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>;
+declare function MappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode>(K: K, M: M, options: SchemaOptions): 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>;
+declare function MappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode>(K: [...K], M: M, options: SchemaOptions): 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>;
+declare function MappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode>(T: K, M: M, options: SchemaOptions): MappedIntrinsicProperties<K, M>;
+export type TIntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = MappedIntrinsicProperties<K, M>> = (TMappedResult<P>);
+export declare function IntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = MappedIntrinsicProperties<K, M>>(T: K, M: M, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/require/type/intrinsic/intrinsic-from-mapped-key.js

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

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

@@ -1,17 +1,17 @@
-import type { TSchema } from '../schema/index';
+import type { TSchema, SchemaOptions } from '../schema/index';
 import { type TTemplateLiteral, type TTemplateLiteralKind } from '../template-literal/index';
-import { type TIntrinsicMappedResult } from './intrinsic-mapped-result';
+import { type TIntrinsicFromMappedKey } from './intrinsic-from-mapped-key';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TUnion } from '../union/index';
 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>;
+declare function FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode>(schema: TTemplateLiteral, mode: IntrinsicMode, options: SchemaOptions): 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[]] ? [TIntrinsic<L, M>, ...FromRest<R, M>] : [];
 declare function FromRest<T extends TSchema[], M extends IntrinsicMode>(T: [...T], mode: M): FromRest<T, M>;
-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 type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicFromMappedKey<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, options?: SchemaOptions): TIntrinsicFromMappedKey<T, M>;
+export declare function Intrinsic<T extends TSchema, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsic<T, M>;
 export {};

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Intrinsic = void 0;
 const index_1 = require("../template-literal/index");
-const intrinsic_mapped_result_1 = require("./intrinsic-mapped-result");
+const intrinsic_from_mapped_key_1 = require("./intrinsic-from-mapped-key");
 const index_2 = require("../literal/index");
 const index_3 = require("../union/index");
 const type_1 = require("../guard/type");
@@ -20,7 +20,7 @@ function ApplyUppercase(value) {
 function ApplyLowercase(value) {
     return value.toLowerCase();
 }
-function FromTemplateLiteral(schema, mode) {
+function FromTemplateLiteral(schema, mode, options) {
     const expression = (0, index_1.TemplateLiteralParseExact)(schema.pattern);
     const finite = (0, index_1.IsTemplateLiteralFinite)(expression);
     if (!finite)
@@ -29,7 +29,7 @@ function FromTemplateLiteral(schema, mode) {
     const literals = strings.map((value) => (0, index_2.Literal)(value));
     const mapped = FromRest(literals, mode);
     const union = (0, index_3.Union)(mapped);
-    return (0, index_1.TemplateLiteral)([union]);
+    return (0, index_1.TemplateLiteral)([union], options);
 }
 function FromLiteralValue(value, mode) {
     return (typeof value === 'string' ? (mode === 'Uncapitalize' ? ApplyUncapitalize(value) :
@@ -42,11 +42,11 @@ function FromRest(T, mode) {
     const [L, ...R] = T;
     return (T.length > 0 ? [Intrinsic(L, mode), ...FromRest(R, mode)] : []);
 }
-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)) :
+function Intrinsic(schema, mode, options = {}) {
+    return ((0, type_1.TMappedKey)(schema) ? (0, intrinsic_from_mapped_key_1.IntrinsicFromMappedKey)(schema, mode, options) :
+        (0, type_1.TTemplateLiteral)(schema) ? FromTemplateLiteral(schema, mode, schema) :
+            (0, type_1.TUnion)(schema) ? (0, index_3.Union)(FromRest(schema.anyOf, mode), options) :
+                (0, type_1.TLiteral)(schema) ? (0, index_2.Literal)(FromLiteralValue(schema.const, mode), options) :
                     schema);
 }
 exports.Intrinsic = Intrinsic;

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

@@ -2,8 +2,7 @@
 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);
+    return (0, intrinsic_1.Intrinsic)(T, 'Lowercase', options);
 }
 exports.Lowercase = Lowercase;

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

@@ -2,8 +2,7 @@
 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);
+    return (0, intrinsic_1.Intrinsic)(T, 'Uncapitalize', options);
 }
 exports.Uncapitalize = Uncapitalize;

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

@@ -2,8 +2,7 @@
 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);
+    return (0, intrinsic_1.Intrinsic)(T, 'Uppercase', options);
 }
 exports.Uppercase = Uppercase;

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

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

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

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

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

@@ -0,0 +1,13 @@
+import type { SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TKeyOf } from './keyof';
+type FromProperties<K extends TProperties> = ({
+    [K2 in keyof K]: TKeyOf<K[K2]>;
+});
+declare function FromProperties<K extends TProperties>(K: K, options: SchemaOptions): FromProperties<K>;
+type FromMappedResult<K extends TMappedResult> = (FromProperties<K['properties']>);
+declare function FromMappedResult<K extends TMappedResult>(K: K, options: SchemaOptions): FromMappedResult<K>;
+export type TKeyOfFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>> = (TMappedResult<P>);
+export declare function KeyOfFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
+export {};

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyOfFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const keyof_1 = require("./keyof");
+function FromProperties(K, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, keyof_1.KeyOf)(K[K2], options) };
+    }, {});
+}
+function FromMappedResult(K, options) {
+    return FromProperties(K.properties, options);
+}
+function KeyOfFromMappedResult(T, options) {
+    const P = FromMappedResult(T, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.KeyOfFromMappedResult = KeyOfFromMappedResult;

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

@@ -1,12 +1,15 @@
 import type { TSchema } from '../schema/index';
 import type { Ensure } from '../helpers/index';
+import type { TMappedResult } from '../mapped/index';
 import { type TLiteral, TLiteralValue } from '../literal/index';
 import { type TNumber } from '../number/index';
 import { type SchemaOptions } from '../schema/index';
 import { KeyOfPropertyKeys } from './keyof-property-keys';
 import { UnionResolve } from '../union/index';
+import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result';
 type FromLiterals<T extends TLiteralValue[]> = (T extends [infer L extends TLiteralValue, ...infer R extends TLiteralValue[]] ? L extends '[number]' ? [TNumber, ...FromLiterals<R>] : [TLiteral<L>, ...FromLiterals<R>] : []);
 declare function FromLiterals<T extends TLiteralValue[]>(T: [...T]): FromLiterals<T>;
 export type TKeyOf<T extends TSchema> = (Ensure<UnionResolve<FromLiterals<KeyOfPropertyKeys<T>>>>);
+export declare function KeyOf<T extends TMappedResult>(T: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
 export declare function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>;
 export {};

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

@@ -6,6 +6,8 @@ const index_2 = require("../number/index");
 const keyof_property_keys_1 = require("./keyof-property-keys");
 const index_3 = require("../union/index");
 const type_1 = require("../clone/type");
+const keyof_from_mapped_result_1 = require("./keyof-from-mapped-result");
+const type_2 = require("../guard/type");
 function FromLiterals(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -15,7 +17,12 @@ function FromLiterals(T) {
         : []);
 }
 function KeyOf(T, options = {}) {
-    const K = (0, index_3.UnionResolve)(FromLiterals((0, keyof_property_keys_1.KeyOfPropertyKeys)(T)));
-    return (0, type_1.CloneType)(K, options);
+    if ((0, type_2.TMappedResult)(T)) {
+        return (0, keyof_from_mapped_result_1.KeyOfFromMappedResult)(T, options);
+    }
+    else {
+        const K = (0, index_3.UnionResolve)(FromLiterals((0, keyof_property_keys_1.KeyOfPropertyKeys)(T)));
+        return (0, type_1.CloneType)(K, options);
+    }
 }
 exports.KeyOf = KeyOf;

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

@@ -1,5 +1,5 @@
 import type { TSchema } from '../schema/index';
-import type { Ensure, Evaluate } from '../helpers/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';
@@ -8,19 +8,22 @@ 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';
-import type { TMappedResult } from './mapped-result';
+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]> : TNever);
+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 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<{

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

@@ -13,21 +13,28 @@ const index_7 = require("../indexed/index");
 const index_8 = require("../intersect/index");
 const index_9 = require("../iterator/index");
 const index_10 = require("../literal/index");
-const index_11 = require("../never/index");
-const index_12 = require("../object/index");
-const index_13 = require("../optional/index");
-const index_14 = require("../promise/index");
-const index_15 = require("../readonly/index");
-const index_16 = require("../tuple/index");
-const index_17 = require("../union/index");
+const index_11 = require("../object/index");
+const index_12 = require("../optional/index");
+const index_13 = require("../promise/index");
+const index_14 = require("../readonly/index");
+const index_15 = require("../tuple/index");
+const index_16 = require("../union/index");
+const mapped_result_1 = require("./mapped-result");
 const type_3 = require("../guard/type");
 function FromMappedResult(K, P) {
     return (K in P
         ? FromSchemaType(K, P[K])
-        : (0, index_11.Never)());
+        : (0, mapped_result_1.MappedResult)(P));
 }
-function FromMappedKey(K, _) {
-    return (0, index_10.Literal)(K);
+function MappedKeyToMappedResultProperties(K, P) {
+    const [L, ...R] = P;
+    return (P.length > 0
+        ? { [L]: (0, index_10.Literal)(L), ...MappedKeyToMappedResultProperties(K, R) }
+        : {});
+}
+function FromMappedKey(K, P) {
+    const R = MappedKeyToMappedResultProperties(K, P);
+    return FromMappedResult(K, R);
 }
 function FromRest(K, T) {
     const [L, ...R] = T;
@@ -41,8 +48,8 @@ function FromProperties(K, T) {
     }, {});
 }
 function FromSchemaType(K, T) {
-    return ((0, type_3.TOptional)(T) ? (0, index_13.Optional)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.OptionalKind]))) :
-        (0, type_3.TReadonly)(T) ? (0, index_15.Readonly)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.ReadonlyKind]))) :
+    return ((0, type_3.TOptional)(T) ? (0, index_12.Optional)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.OptionalKind]))) :
+        (0, type_3.TReadonly)(T) ? (0, index_14.Readonly)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.ReadonlyKind]))) :
             (0, type_3.TMappedResult)(T) ? FromMappedResult(K, T.properties) :
                 (0, type_3.TMappedKey)(T) ? FromMappedKey(K, T.keys) :
                     (0, type_3.TConstructor)(T) ? (0, index_5.Constructor)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
@@ -50,11 +57,11 @@ function FromSchemaType(K, T) {
                             (0, type_3.TAsyncIterator)(T) ? (0, index_4.AsyncIterator)(FromSchemaType(K, T.items)) :
                                 (0, type_3.TIterator)(T) ? (0, index_9.Iterator)(FromSchemaType(K, T.items)) :
                                     (0, type_3.TIntersect)(T) ? (0, index_8.Intersect)(FromRest(K, T.allOf)) :
-                                        (0, type_3.TUnion)(T) ? (0, index_17.Union)(FromRest(K, T.anyOf)) :
-                                            (0, type_3.TTuple)(T) ? (0, index_16.Tuple)(FromRest(K, T.items ?? [])) :
-                                                (0, type_3.TObject)(T) ? (0, index_12.Object)(FromProperties(K, T.properties)) :
+                                        (0, type_3.TUnion)(T) ? (0, index_16.Union)(FromRest(K, T.anyOf)) :
+                                            (0, type_3.TTuple)(T) ? (0, index_15.Tuple)(FromRest(K, T.items ?? [])) :
+                                                (0, type_3.TObject)(T) ? (0, index_11.Object)(FromProperties(K, T.properties)) :
                                                     (0, type_3.TArray)(T) ? (0, index_3.Array)(FromSchemaType(K, T.items)) :
-                                                        (0, type_3.TPromise)(T) ? (0, index_14.Promise)(FromSchemaType(K, T.item)) :
+                                                        (0, type_3.TPromise)(T) ? (0, index_13.Promise)(FromSchemaType(K, T.item)) :
                                                             T);
 }
 function FromMappedFunctionReturnType(K, T) {
@@ -67,6 +74,6 @@ function Mapped(key, map, options = {}) {
     const K = (0, type_1.TSchema)(key) ? (0, index_7.IndexPropertyKeys)(key) : key;
     const RT = map({ [index_1.Kind]: 'MappedKey', keys: K });
     const R = FromMappedFunctionReturnType(K, RT);
-    return (0, type_2.CloneType)((0, index_12.Object)(R), options);
+    return (0, type_2.CloneType)((0, index_11.Object)(R), options);
 }
 exports.Mapped = Mapped;

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

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

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

@@ -14,5 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./omit-mapped-result"), exports);
+__exportStar(require("./omit-from-mapped-key"), exports);
 __exportStar(require("./omit"), exports);

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

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+import { type TOmit } from './omit';
+type FromPropertyKey<T extends TSchema, K extends PropertyKey> = {
+    [_ in K]: TOmit<T, [K]>;
+};
+declare function FromPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K, options: SchemaOptions): FromPropertyKey<T, K>;
+type FromPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? FromPropertyKey<T, LK> & FromPropertyKeys<T, RK> : {});
+declare function FromPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): FromPropertyKeys<T, K>;
+type FromMappedKey<T extends TSchema, K extends TMappedKey> = (FromPropertyKeys<T, K['keys']>);
+declare function FromMappedKey<T extends TSchema, K extends TMappedKey>(T: T, K: K, options: SchemaOptions): FromMappedKey<T, K>;
+export type TOmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = FromMappedKey<T, K>> = (TMappedResult<P>);
+export declare function OmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = FromMappedKey<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
+export {};

package/build/require/type/omit/omit-from-mapped-key.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmitFromMappedKey = void 0;
+const index_1 = require("../mapped/index");
+const omit_1 = require("./omit");
+function FromPropertyKey(T, K, options) {
+    return {
+        [K]: (0, omit_1.Omit)(T, [K], options)
+    };
+}
+function FromPropertyKeys(T, K, options) {
+    const [LK, ...RK] = K;
+    return (K.length > 0
+        ? { ...FromPropertyKey(T, LK, options), ...FromPropertyKeys(T, RK, options) }
+        : {});
+}
+function FromMappedKey(T, K, options) {
+    return FromPropertyKeys(T, K.keys, options);
+}
+function OmitFromMappedKey(T, K, options) {
+    const P = FromMappedKey(T, K, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.OmitFromMappedKey = OmitFromMappedKey;

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

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