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

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

@@ -0,0 +1,18 @@
+import { IndexResult } from './indexed-result.mjs';
+import { MappedResult } from '../mapped/index.mjs';
+function MappedIndexPropertyKey(T, K, options) {
+    return { [K]: 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);
+}
+export function IndexFromMappedKey(T, K, options) {
+    const P = MappedIndexProperties(T, K, options);
+    return MappedResult(P);
+}

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

@@ -1,4 +1,4 @@
-import { type TSchema } from '../schema/index.mjs';
+import { type TSchema, SchemaOptions } from '../schema/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { type TRecursive } from '../recursive/index.mjs';
@@ -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/import/type/indexed/indexed-result.mjs

@@ -1,6 +1,7 @@
 import { Never } from '../never/index.mjs';
 import { IntersectResolve } from '../intersect/index.mjs';
 import { UnionResolve } from '../union/index.mjs';
+import { CloneType } from '../clone/type.mjs';
 import { TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType, TArray as IsArrayType, TObject as IsObjectType, TNever as IsNeverType } from '../guard/type.mjs';
 function FromRest(T, K) {
     const [L, ...R] = T;
@@ -59,6 +60,6 @@ function FromKeys(T, K) {
         ? [FromKey(T, L), ...FromKeys(T, R)]
         : []);
 }
-export function IndexResult(T, K) {
-    return (UnionResolve(FromKeys(T, K)));
+export function IndexResult(T, K, options) {
+    return (CloneType(UnionResolve(FromKeys(T, K)), options));
 }

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

@@ -1,9 +1,9 @@
 import type { TSchema, SchemaOptions } from '../schema/index.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 { type TIndexFromMappedKey } from './indexed-from-mapped-key.mjs';
 import { TMappedKey } from '../mapped/index.mjs';
 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/import/type/indexed/indexed.mjs

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

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

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

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

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

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

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

package/build/import/type/intrinsic/{intrinsic-mapped-result.d.mts → intrinsic-from-mapped-key.d.mts}

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

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

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

@@ -1,5 +1,5 @@
 import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralGenerate } from '../template-literal/index.mjs';
-import { IntrinsicMappedResult } from './intrinsic-mapped-result.mjs';
+import { IntrinsicFromMappedKey } from './intrinsic-from-mapped-key.mjs';
 import { Literal } from '../literal/index.mjs';
 import { Union } from '../union/index.mjs';
 import { TMappedKey as IsMappedKeyType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType } from '../guard/type.mjs';
@@ -17,7 +17,7 @@ function ApplyUppercase(value) {
 function ApplyLowercase(value) {
     return value.toLowerCase();
 }
-function FromTemplateLiteral(schema, mode) {
+function FromTemplateLiteral(schema, mode, options) {
     const expression = TemplateLiteralParseExact(schema.pattern);
     const finite = IsTemplateLiteralFinite(expression);
     if (!finite)
@@ -26,7 +26,7 @@ function FromTemplateLiteral(schema, mode) {
     const literals = strings.map((value) => Literal(value));
     const mapped = FromRest(literals, mode);
     const union = Union(mapped);
-    return TemplateLiteral([union]);
+    return TemplateLiteral([union], options);
 }
 function FromLiteralValue(value, mode) {
     return (typeof value === 'string' ? (mode === 'Uncapitalize' ? ApplyUncapitalize(value) :
@@ -39,10 +39,10 @@ function FromRest(T, mode) {
     const [L, ...R] = T;
     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)) :
+export function Intrinsic(schema, mode, options = {}) {
+    return (IsMappedKeyType(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
+        IsTemplateLiteralType(schema) ? FromTemplateLiteral(schema, mode, schema) :
+            IsUnionType(schema) ? Union(FromRest(schema.anyOf, mode), options) :
+                IsLiteralType(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :
                     schema);
 }

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { KeyOf } from './keyof.mjs';
+function FromProperties(K, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: KeyOf(K[K2], options) };
+    }, {});
+}
+function FromMappedResult(K, options) {
+    return FromProperties(K.properties, options);
+}
+export function KeyOfFromMappedResult(T, options) {
+    const P = FromMappedResult(T, options);
+    return MappedResult(P);
+}

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

@@ -1,12 +1,15 @@
 import type { TSchema } from '../schema/index.mjs';
 import type { Ensure } from '../helpers/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
 import { type TLiteral, TLiteralValue } from '../literal/index.mjs';
 import { type TNumber } from '../number/index.mjs';
 import { type SchemaOptions } from '../schema/index.mjs';
 import { KeyOfPropertyKeys } from './keyof-property-keys.mjs';
 import { UnionResolve } from '../union/index.mjs';
+import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
 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/import/type/keyof/keyof.mjs

@@ -3,6 +3,8 @@ import { Number } from '../number/index.mjs';
 import { KeyOfPropertyKeys } from './keyof-property-keys.mjs';
 import { UnionResolve } from '../union/index.mjs';
 import { CloneType } from '../clone/type.mjs';
+import { KeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
+import { TMappedResult as IsMappedResultType } from '../guard/type.mjs';
 function FromLiterals(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -12,6 +14,11 @@ function FromLiterals(T) {
         : []);
 }
 export function KeyOf(T, options = {}) {
-    const K = UnionResolve(FromLiterals(KeyOfPropertyKeys(T)));
-    return CloneType(K, options);
+    if (IsMappedResultType(T)) {
+        return KeyOfFromMappedResult(T, options);
+    }
+    else {
+        const K = UnionResolve(FromLiterals(KeyOfPropertyKeys(T)));
+        return CloneType(K, options);
+    }
 }

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

@@ -1,5 +1,5 @@
 import type { TSchema } from '../schema/index.mjs';
-import type { Ensure, Evaluate } from '../helpers/index.mjs';
+import type { Ensure, Evaluate, Assert } from '../helpers/index.mjs';
 import { type TArray } from '../array/index.mjs';
 import { type TAsyncIterator } from '../async-iterator/index.mjs';
 import { type TConstructor } from '../constructor/index.mjs';
@@ -8,19 +8,22 @@ import { type TIndexPropertyKeys } from '../indexed/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TIterator } from '../iterator/index.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
-import { type TNever } from '../never/index.mjs';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import { type TPromise } from '../promise/index.mjs';
 import { type TReadonly } from '../readonly/index.mjs';
 import { type TTuple } from '../tuple/index.mjs';
 import { type TUnion } from '../union/index.mjs';
-import type { TMappedResult } from './mapped-result.mjs';
+import { type TMappedResult } from './mapped-result.mjs';
 import type { TMappedKey } from './mapped-key.mjs';
-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/import/type/mapped/mapped.mjs

@@ -10,21 +10,28 @@ import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Iterator } from '../iterator/index.mjs';
 import { Literal } from '../literal/index.mjs';
-import { Never } from '../never/index.mjs';
 import { Object } from '../object/index.mjs';
 import { Optional } from '../optional/index.mjs';
 import { Promise } from '../promise/index.mjs';
 import { Readonly } from '../readonly/index.mjs';
 import { Tuple } from '../tuple/index.mjs';
 import { Union } from '../union/index.mjs';
+import { MappedResult } from './mapped-result.mjs';
 import { TArray as IsArrayType, TAsyncIterator as IsAsyncIteratorType, TConstructor as IsConstructorType, TFunction as IsFunctionType, TIntersect as IsIntersectType, TIterator as IsIteratorType, TReadonly as IsReadonlyType, TMappedResult as IsMappedResultType, TMappedKey as IsMappedKeyType, TObject as IsObjectType, TOptional as IsOptionalType, TPromise as IsPromiseType, TTuple as IsTupleType, TUnion as IsUnionType, } from '../guard/type.mjs';
 function FromMappedResult(K, P) {
     return (K in P
         ? FromSchemaType(K, P[K])
-        : Never());
+        : MappedResult(P));
 }
-function FromMappedKey(K, _) {
-    return Literal(K);
+function MappedKeyToMappedResultProperties(K, P) {
+    const [L, ...R] = P;
+    return (P.length > 0
+        ? { [L]: 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;

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
+import { type TOmit } from './omit.mjs';
+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/import/type/omit/omit-from-mapped-key.mjs

@@ -0,0 +1,20 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Omit } from './omit.mjs';
+function FromPropertyKey(T, K, options) {
+    return {
+        [K]: 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);
+}
+export function OmitFromMappedKey(T, K, options) {
+    const P = FromMappedKey(T, K, options);
+    return MappedResult(P);
+}

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

@@ -6,7 +6,7 @@ import { type TUnion } from '../union/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TIndexPropertyKeys } from '../indexed/index.mjs';
 import { TMappedKey } from '../mapped/index.mjs';
-import { type TOmitMappedResult } from './omit-mapped-result.mjs';
+import { type TOmitFromMappedKey } from './omit-from-mapped-key.mjs';
 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 {};

package/build/import/type/omit/omit.mjs

@@ -5,7 +5,7 @@ import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-import { OmitMappedResult } from './omit-mapped-result.mjs';
+import { OmitFromMappedKey } from './omit-from-mapped-key.mjs';
 import { TMappedKey as IsMappedKeyType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
 function FromIntersect(T, K) {
     return T.map((T) => OmitResolve(T, K));
@@ -30,7 +30,7 @@ export function OmitResolve(T, K) {
 }
 export function Omit(T, K, options = {}) {
     if (IsMappedKeyType(K)) {
-        return OmitMappedResult(T, K);
+        return OmitFromMappedKey(T, K, options);
     }
     else {
         const I = IsSchemaType(K) ? IndexPropertyKeys(K) : K;

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

@@ -1 +1,2 @@
+export * from './partial-from-mapped-result.mjs';
 export * from './partial.mjs';

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

@@ -1 +1,2 @@
+export * from './partial-from-mapped-result.mjs';
 export * from './partial.mjs';

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

@@ -0,0 +1,13 @@
+import type { SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TPartial } from './partial.mjs';
+type FromProperties<K extends TProperties> = ({
+    [K2 in keyof K]: TPartial<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 TPartialFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>> = (TMappedResult<P>);
+export declare function PartialFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
+export {};

package/build/import/type/partial/partial-from-mapped-result.mjs

@@ -0,0 +1,14 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Partial } from './partial.mjs';
+function FromProperties(K, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Partial(K[K2], options) };
+    }, {});
+}
+function FromMappedResult(K, options) {
+    return FromProperties(K.properties, options);
+}
+export function PartialFromMappedResult(T, options) {
+    const P = FromMappedResult(T, options);
+    return MappedResult(P);
+}

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

@@ -1,5 +1,6 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Evaluate } from '../helpers/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import { type TReadonly } from '../readonly/index.mjs';
@@ -7,6 +8,7 @@ import { type TRecursive } from '../recursive/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
+import { type TPartialFromMappedResult } from './partial-from-mapped-result.mjs';
 type FromIntersect<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PartialResolve<L>, ...FromIntersect<R>] : []);
 declare function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T>;
 type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PartialResolve<L>, ...FromUnion<R>] : []);
@@ -15,8 +17,9 @@ type FromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : T[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<T[K]>;
 }>;
 declare function FromProperties<T extends TProperties>(T: T): TProperties;
-export type PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
-export declare function PartialResolve<T extends TSchema>(T: T): PartialResolve<T>;
+type PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
+declare function PartialResolve<T extends TSchema>(T: T): PartialResolve<T>;
 export type TPartial<T extends TSchema> = PartialResolve<T>;
+export declare function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>;
 export declare function Partial<T extends TSchema>(T: T, options?: SchemaOptions): TPartial<T>;
 export {};

package/build/import/type/partial/partial.mjs

@@ -5,7 +5,8 @@ import { Union } from '../union/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-import { TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType } from '../guard/type.mjs';
+import { PartialFromMappedResult } from './partial-from-mapped-result.mjs';
+import { TMappedResult as IsMappedResultType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType } from '../guard/type.mjs';
 function FromIntersect(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -23,14 +24,19 @@ function FromProperties(T) {
         return { ...Acc, [K]: Optional(T[K]) };
     }, {});
 }
-export function PartialResolve(T) {
+function PartialResolve(T) {
     return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf)) :
         IsUnionType(T) ? Union(FromUnion(T.anyOf)) :
             IsObjectType(T) ? Object(FromProperties(T.properties)) :
                 Object({}));
 }
 export function Partial(T, options = {}) {
-    const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(PartialResolve(T), options);
-    return { ...D, ...R };
+    if (IsMappedResultType(T)) {
+        return PartialFromMappedResult(T, options);
+    }
+    else {
+        const D = Discard(T, [TransformKind, '$id', 'required']);
+        const R = CloneType(PartialResolve(T), options);
+        return { ...D, ...R };
+    }
 }

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

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

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

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