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

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

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

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

@@ -6,11 +6,11 @@ import { type TSchema } from '../schema/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 type FromTemplateLiteral<T extends TTemplateLiteral, F = IsTemplateLiteralFinite<T>> = (F extends true ? TemplateLiteralGenerate<T> extends infer R extends string[] ? R : [] : []);
 declare function FromTemplateLiteral<T extends TTemplateLiteral>(T: T): FromTemplateLiteral<T>;
-type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...IndexedPropertyKeys<L>, ...FromUnion<R>] : []);
+type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...TIndexPropertyKeys<L>, ...FromUnion<R>] : []);
 declare function FromUnion<T extends TSchema[]>(T: T): FromUnion<T>;
 type FromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] : []);
 declare function FromLiteral<T extends TLiteralValue>(T: T): FromLiteral<T>;
-export type IndexedPropertyKeys<T extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T> : T extends TUnion<infer S> ? FromUnion<S> : T extends TLiteral<infer S> ? FromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
+export type TIndexPropertyKeys<T extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T> : T extends TUnion<infer S> ? FromUnion<S> : T extends TLiteral<infer S> ? FromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
 ]);
-export declare function IndexedPropertyKeys<T extends TSchema>(T: T): IndexedPropertyKeys<T>;
+export declare function IndexPropertyKeys<T extends TSchema>(T: T): TIndexPropertyKeys<T>;
 export {};

package/build/import/type/indexed/indexed-property-keys.mjs

@@ -13,13 +13,13 @@ function FromTemplateLiteral(T) {
 function FromUnion(T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [...IndexedPropertyKeys(L), ...FromUnion(R)]
+        ? [...IndexPropertyKeys(L), ...FromUnion(R)]
         : []);
 }
 function FromLiteral(T) {
     return ([T.toString()]);
 }
-export function IndexedPropertyKeys(T) {
+export function IndexPropertyKeys(T) {
     return [...new Set((IsTemplateLiteralType(T) ? FromTemplateLiteral(T) :
             IsUnionType(T) ? FromUnion(T.anyOf) :
                 IsLiteralType(T) ? FromLiteral(T.const) :

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

@@ -28,6 +28,6 @@ type FromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<i
 declare function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromKey<T, K>;
 type FromKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? [FromKey<T, L>, ...FromKeys<T, R>] : []);
 declare function FromKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromKeys<T, K>;
-export type IndexedType<T extends TSchema, K extends PropertyKey[]> = (UnionResolve<FromKeys<T, K>>);
-export declare function IndexedType<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): IndexedType<T, K>;
+export type TIndexResult<T extends TSchema, K extends PropertyKey[]> = (UnionResolve<FromKeys<T, K>>);
+export declare function IndexResult<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TIndexResult<T, K>;
 export {};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/build/import/type/intrinsic/intrinsic-mapped-result.mjs

@@ -0,0 +1,21 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Intrinsic } from './intrinsic.mjs';
+import { Literal } from '../literal/index.mjs';
+function MappedIntrinsicPropertyKey(K, M) {
+    return {
+        [K]: Intrinsic(Literal(K), M)
+    };
+}
+function MappedIntrinsicPropertyKeys(K, M) {
+    const [L, ...R] = K;
+    return (K.length > 0
+        ? { ...MappedIntrinsicPropertyKey(L, M), ...MappedIntrinsicPropertyKeys(R, M) }
+        : {});
+}
+function MappedIntrinsicProperties(T, M) {
+    return MappedIntrinsicPropertyKeys(T['keys'], M);
+}
+export function IntrinsicMappedResult(T, M) {
+    const P = MappedIntrinsicProperties(T, M);
+    return MappedResult(P);
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,50 +1,43 @@
 import type { TSchema } from '../schema/index.mjs';
-import type { Ensure, Evaluate } from '../helpers/index.mjs';
-import { IndexedPropertyKeys } from '../indexed/index.mjs';
-import { Kind } from '../symbols/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';
 import { type TFunction } from '../function/index.mjs';
+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';
-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.mjs';
+import type { TMappedKey } from './mapped-key.mjs';
+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 {};

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

@@ -1,4 +1,3 @@
-import { IndexedPropertyKeys } from '../indexed/index.mjs';
 import { TSchema as IsSchemaType } from '../guard/type.mjs';
 import { Kind, OptionalKind, ReadonlyKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
@@ -7,72 +6,70 @@ import { Array } from '../array/index.mjs';
 import { AsyncIterator } from '../async-iterator/index.mjs';
 import { Constructor } from '../constructor/index.mjs';
 import { Function as FunctionType } from '../function/index.mjs';
+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 { TOptional as IsOptionalType, TReadonly as IsReadonlyType, TMappedResult as IsMappedResultType, TMappedKey as IsMappedKeyType, TConstructor as IsConstructorType, TFunction as IsFunctionType, TAsyncIterator as IsAsyncIteratorType, TIterator as IsIteratorType, TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TArray as IsArrayType, TPromise as IsPromiseType, } from '../guard/type.mjs';
-export function MappedKey(T) {
-    return {
-        [Kind]: 'MappedKey',
-        keys: T
-    };
-}
+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
-        ? FromMappedPropertyKey(K, P[K])
-        : Never());
+        ? FromSchemaType(K, P[K])
+        : MappedResult(P));
+}
+function MappedKeyToMappedResultProperties(K, P) {
+    const [L, ...R] = P;
+    return (P.length > 0
+        ? { [L]: Literal(L), ...MappedKeyToMappedResultProperties(K, R) }
+        : {});
 }
-function FromMappedKey(K, _) {
-    return Literal(K);
+function FromMappedKey(K, P) {
+    const R = MappedKeyToMappedResultProperties(K, P);
+    return FromMappedResult(K, R);
 }
 function FromRest(K, T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [FromMappedPropertyKey(K, L), ...FromRest(K, R)]
+        ? [FromSchemaType(K, L), ...FromRest(K, R)]
         : []);
 }
 function FromProperties(K, T) {
     return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: FromMappedPropertyKey(K, T[K2]) };
+        return { ...Acc, [K2]: FromSchemaType(K, T[K2]) };
     }, {});
 }
-export function FromMappedPropertyKey(K, T) {
-    return (IsOptionalType(T) ? Optional(FromMappedPropertyKey(K, Discard(T, [OptionalKind]))) :
-        IsReadonlyType(T) ? Readonly(FromMappedPropertyKey(K, Discard(T, [ReadonlyKind]))) :
+function FromSchemaType(K, T) {
+    return (IsOptionalType(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) :
+        IsReadonlyType(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) :
             IsMappedResultType(T) ? FromMappedResult(K, T.properties) :
                 IsMappedKeyType(T) ? FromMappedKey(K, T.keys) :
-                    IsConstructorType(T) ? Constructor(FromRest(K, T.parameters), FromMappedPropertyKey(K, T.returns)) :
-                        IsFunctionType(T) ? FunctionType(FromRest(K, T.parameters), FromMappedPropertyKey(K, T.returns)) :
-                            IsAsyncIteratorType(T) ? AsyncIterator(FromMappedPropertyKey(K, T.items)) :
-                                IsIteratorType(T) ? Iterator(FromMappedPropertyKey(K, T.items)) :
+                    IsConstructorType(T) ? Constructor(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                        IsFunctionType(T) ? FunctionType(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                            IsAsyncIteratorType(T) ? AsyncIterator(FromSchemaType(K, T.items)) :
+                                IsIteratorType(T) ? Iterator(FromSchemaType(K, T.items)) :
                                     IsIntersectType(T) ? Intersect(FromRest(K, T.allOf)) :
                                         IsUnionType(T) ? Union(FromRest(K, T.anyOf)) :
-                                            IsObjectType(T) ? Object(FromProperties(K, T.properties)) :
-                                                IsArrayType(T) ? Array(FromMappedPropertyKey(K, T.items)) :
-                                                    IsPromiseType(T) ? Promise(FromMappedPropertyKey(K, T.item)) :
-                                                        T);
+                                            IsTupleType(T) ? Tuple(FromRest(K, T.items ?? [])) :
+                                                IsObjectType(T) ? Object(FromProperties(K, T.properties)) :
+                                                    IsArrayType(T) ? Array(FromSchemaType(K, T.items)) :
+                                                        IsPromiseType(T) ? Promise(FromSchemaType(K, T.item)) :
+                                                            T);
 }
-export function FromMappedPropertyKeys(K, T) {
+function FromMappedFunctionReturnType(K, T) {
     const [L, ...R] = K;
     return (K.length > 0
-        ? { [L]: FromMappedPropertyKey(L, T), ...FromMappedPropertyKeys(R, T) }
+        ? { [L]: FromSchemaType(L, T), ...FromMappedFunctionReturnType(R, T) }
         : {});
 }
-export function MappedResult(properties) {
-    return {
-        [Kind]: 'MappedResult',
-        properties
-    };
-}
 export function Mapped(key, map, options = {}) {
-    const K = IsSchemaType(key) ? IndexedPropertyKeys(key) : key;
+    const K = IsSchemaType(key) ? IndexPropertyKeys(key) : key;
     const RT = map({ [Kind]: 'MappedKey', keys: K });
-    const R = FromMappedPropertyKeys(K, RT);
+    const R = FromMappedFunctionReturnType(K, RT);
     return CloneType(Object(R), options);
 }

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { TSchema } 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 MappedOmitPropertyKey<T extends TSchema, K extends PropertyKey> = {
+    [_ in K]: TOmit<T, [K]>;
+};
+declare function MappedOmitPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): MappedOmitPropertyKey<T, K>;
+type MappedOmitPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? MappedOmitPropertyKey<T, LK> & MappedOmitPropertyKeys<T, RK> : {});
+declare function MappedOmitPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): MappedOmitPropertyKeys<T, K>;
+type MappedOmitProperties<T extends TSchema, K extends TMappedKey> = (MappedOmitPropertyKeys<T, K['keys']>);
+declare function MappedOmitProperties<T extends TSchema, K extends TMappedKey>(T: T, K: K): MappedOmitProperties<T, K>;
+export type TOmitMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedOmitProperties<T, K>> = (TMappedResult<P>);
+export declare function OmitMappedResult<T extends TSchema, K extends TMappedKey, P extends TProperties = MappedOmitProperties<T, K>>(T: T, K: K): TMappedResult<P>;
+export {};

package/build/import/type/omit/omit-mapped-result.mjs

@@ -0,0 +1,20 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Omit } from './omit.mjs';
+function MappedOmitPropertyKey(T, K) {
+    return {
+        [K]: Omit(T, [K])
+    };
+}
+function MappedOmitPropertyKeys(T, K) {
+    const [LK, ...RK] = K;
+    return (K.length > 0
+        ? { ...MappedOmitPropertyKey(T, LK), ...MappedOmitPropertyKeys(T, RK) }
+        : {});
+}
+function MappedOmitProperties(T, K) {
+    return MappedOmitPropertyKeys(T, K.keys);
+}
+export function OmitMappedResult(T, K) {
+    const P = MappedOmitProperties(T, K);
+    return MappedResult(P);
+}