@sinclair/typebox 0.32.5 → 0.32.6

package/build/import/index.d.mts

@@ -18,19 +18,19 @@ export { Date, type TDate, type DateOptions } from './type/date/index.mjs';
 export { Deref, type TDeref } from './type/deref/index.mjs';
 export { Enum, type TEnum } from './type/enum/index.mjs';
 export { Exclude, type TExclude, type TExcludeFromMappedResult } from './type/exclude/index.mjs';
-export { Extends, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index.mjs';
+export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey } from './type/extends/index.mjs';
 export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index.mjs';
 export { Function, type TFunction } from './type/function/index.mjs';
 export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index.mjs';
-export { Index, IndexPropertyKeys, IndexFromMappedKey, IndexFromMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from './type/indexed/index.mjs';
+export { Index, IndexPropertyKeys, IndexFromPropertyKeys, IndexFromPropertyKey, IndexFromMappedKey, IndexFromMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexFromPropertyKeys, type TIndexFromPropertyKey, type TIndexFromMappedKey, type TIndexFromMappedResult, } from './type/indexed/index.mjs';
 export { InstanceType, type TInstanceType } from './type/instance-type/index.mjs';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index.mjs';
 export { Intersect, IntersectEvaluated, type TIntersect, type TIntersectEvaluated, type IntersectOptions } from './type/intersect/index.mjs';
 export { Iterator, type TIterator } from './type/iterator/index.mjs';
 export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index.mjs';
-export { KeyOf, type TKeyOf, type KeyOfFromMappedResult, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index.mjs';
+export { KeyOf, KeyOfPropertyKeys, KeyOfPropertyKeysToRest, KeyOfFromMappedResult, KeyOfPattern, type TKeyOf, type TKeyOfPropertyKeys, type TKeyOfPropertyKeysToRest, type TKeyOfFromMappedResult } from './type/keyof/index.mjs';
 export { Literal, type TLiteral, type TLiteralValue } from './type/literal/index.mjs';
-export { Mapped, MappedKey, MappedResult, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction } from './type/mapped/index.mjs';
+export { Mapped, MappedKey, MappedResult, MappedFunctionReturnType, type TMapped, type TMappedKey, type TMappedResult, type TMappedFunction, type TMappedFunctionReturnType } from './type/mapped/index.mjs';
 export { Never, type TNever } from './type/never/index.mjs';
 export { Not, type TNot } from './type/not/index.mjs';
 export { Null, type TNull } from './type/null/index.mjs';
@@ -44,7 +44,7 @@ export { Pick, type TPick, type TPickFromMappedKey, type TPickFromMappedResult }
 export { Promise, type TPromise } from './type/promise/index.mjs';
 export { Readonly, ReadonlyFromMappedResult, type TReadonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from './type/readonly/index.mjs';
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index.mjs';
-export { Record, type TRecord } from './type/record/index.mjs';
+export { Record, type TRecord, type TRecordOrObject } from './type/record/index.mjs';
 export { Recursive, type TRecursive, type TThis } from './type/recursive/index.mjs';
 export { Ref, type TRef } from './type/ref/index.mjs';
 export { RegExp, type TRegExp } from './type/regexp/index.mjs';
@@ -52,11 +52,11 @@ export { Required, type TRequired, type TRequiredFromMappedResult } from './type
 export { Rest, type TRest } from './type/rest/index.mjs';
 export { ReturnType, type TReturnType } from './type/return-type/index.mjs';
 export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from './type/schema/index.mjs';
-export { type Static, type StaticDecode, type StaticEncode } from './type/static/index.mjs';
+export { type Static, type StaticDecode, type StaticEncode, type TDecodeType, type TDecodeRest, type TDecodeProperties } from './type/static/index.mjs';
 export { Strict } from './type/strict/index.mjs';
 export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index.mjs';
 export { Symbol, type TSymbol, type TSymbolValue as SymbolValue } from './type/symbol/index.mjs';
-export { TemplateLiteral, IsTemplateLiteralFinite, IsTemplateLiteralExpressionFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, TemplateLiteralExpressionGenerate, type TTemplateLiteral, type TIsTemplateLiteralFinite, type TTemplateLiteralGenerate, type TTemplateLiteralKind, } from './type/template-literal/index.mjs';
+export { TemplateLiteral, TemplateLiteralSyntax, TemplateLiteralGenerate, TemplateLiteralParse, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralExpressionGenerate, IsTemplateLiteralExpressionFinite, type TTemplateLiteral, type TTemplateLiteralSyntax, type TTemplateLiteralGenerate, type TTemplateLiteralKind, type TIsTemplateLiteralFinite, } from './type/template-literal/index.mjs';
 export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } from './type/transform/index.mjs';
 export { Tuple, type TTuple } from './type/tuple/index.mjs';
 export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index.mjs';

package/build/import/index.mjs

@@ -28,15 +28,15 @@ export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './t
 export { Extract } from './type/extract/index.mjs';
 export { Function } from './type/function/index.mjs';
 export { Increment } from './type/helpers/index.mjs';
-export { Index, IndexPropertyKeys, IndexFromMappedKey, IndexFromMappedResult } from './type/indexed/index.mjs';
+export { Index, IndexPropertyKeys, IndexFromPropertyKeys, IndexFromPropertyKey, IndexFromMappedKey, IndexFromMappedResult, } from './type/indexed/index.mjs';
 export { InstanceType } from './type/instance-type/index.mjs';
 export { Integer } from './type/integer/index.mjs';
 export { Intersect, IntersectEvaluated } from './type/intersect/index.mjs';
 export { Iterator } from './type/iterator/index.mjs';
 export { Intrinsic, IntrinsicFromMappedKey, Capitalize, Lowercase, Uncapitalize, Uppercase } from './type/intrinsic/index.mjs';
-export { KeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index.mjs';
+export { KeyOf, KeyOfPropertyKeys, KeyOfPropertyKeysToRest, KeyOfFromMappedResult, KeyOfPattern } from './type/keyof/index.mjs';
 export { Literal } from './type/literal/index.mjs';
-export { Mapped, MappedKey, MappedResult } from './type/mapped/index.mjs';
+export { Mapped, MappedKey, MappedResult, MappedFunctionReturnType } from './type/mapped/index.mjs';
 export { Never } from './type/never/index.mjs';
 export { Not } from './type/not/index.mjs';
 export { Null } from './type/null/index.mjs';
@@ -60,7 +60,7 @@ export { ReturnType } from './type/return-type/index.mjs';
 export { Strict } from './type/strict/index.mjs';
 export { String } from './type/string/index.mjs';
 export { Symbol } from './type/symbol/index.mjs';
-export { TemplateLiteral, IsTemplateLiteralFinite, IsTemplateLiteralExpressionFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, TemplateLiteralExpressionGenerate, } from './type/template-literal/index.mjs';
+export { TemplateLiteral, TemplateLiteralSyntax, TemplateLiteralGenerate, TemplateLiteralParse, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralExpressionGenerate, IsTemplateLiteralExpressionFinite, } from './type/template-literal/index.mjs';
 export { Transform, TransformDecodeBuilder, TransformEncodeBuilder } from './type/transform/index.mjs';
 export { Tuple } from './type/tuple/index.mjs';
 export { Uint8Array } from './type/uint8array/index.mjs';

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

@@ -2,9 +2,8 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TPromise } from '../promise/index.mjs';
-type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TFromSchema<L>]> : Acc;
-type TFromSchema<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TPromise<infer S> ? TFromSchema<S> : T;
-export type TAwaited<T extends TSchema> = (TFromSchema<T>);
+type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TAwaited<L>]> : Acc;
+export type TAwaited<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TPromise<infer S> ? TAwaited<S> : T;
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-export declare function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): TFromSchema<T>;
+export declare function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): TAwaited<T>;
 export {};

package/build/import/type/awaited/awaited.mjs

@@ -7,7 +7,7 @@ import { CloneType } from '../clone/type.mjs';
 import { IsIntersect, IsUnion, IsPromise } from '../guard/type.mjs';
 // prettier-ignore
 function FromRest(T) {
-    return T.map(L => FromSchema(L));
+    return T.map(L => AwaitedResolve(L));
 }
 // prettier-ignore
 function FromIntersect(T) {
@@ -19,10 +19,13 @@ function FromUnion(T) {
 }
 // prettier-ignore
 function FromPromise(T) {
-    return FromSchema(T);
+    return AwaitedResolve(T);
 }
+// ----------------------------------------------------------------
+// AwaitedResolve
+// ----------------------------------------------------------------
 // prettier-ignore
-function FromSchema(T) {
+function AwaitedResolve(T) {
     return (IsIntersect(T) ? FromIntersect(T.allOf) :
         IsUnion(T) ? FromUnion(T.anyOf) :
             IsPromise(T) ? FromPromise(T.item) :
@@ -30,5 +33,5 @@ function FromSchema(T) {
 }
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
 export function Awaited(T, options = {}) {
-    return CloneType(FromSchema(T), options);
+    return CloneType(AwaitedResolve(T), options);
 }

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

@@ -1,4 +1,4 @@
-import type { UnionToTuple, Assert, Evaluate } from '../helpers/index.mjs';
+import type { UnionToTuple, Assert, Ensure, Evaluate } from '../helpers/index.mjs';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TIndex } from '../indexed/index.mjs';
@@ -7,8 +7,7 @@ type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[], Acc ex
     [_ in L]: TIndex<T, [L]>;
 }> : Acc;
 type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
-type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<TCompositeReduce<T>> : TObject<{}>;
-export type TComposite<T extends TObject[]> = TCompositeResolve<T>;
+export type TComposite<T extends TObject[]> = TIntersect<T> extends TIntersect ? Ensure<TObject<TCompositeReduce<T>>> : Ensure<TObject<{}>>;
 /** `[Json]` Creates a Composite object type */
 export declare function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T>;
 export {};

package/build/import/type/composite/composite.mjs

@@ -2,14 +2,10 @@ import { Object } from '../object/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Index } from '../indexed/index.mjs';
 import { KeyOfPropertyKeys } from '../keyof/index.mjs';
-import { CloneType } from '../clone/type.mjs';
-function CompositeResolve(T) {
+/** `[Json]` Creates a Composite object type */
+export function Composite(T, options) {
     const intersect = Intersect(T, {});
     const keys = KeyOfPropertyKeys(intersect);
     const properties = keys.reduce((acc, key) => ({ ...acc, [key]: Index(intersect, [key]) }), {});
-    return Object(properties);
-}
-/** `[Json]` Creates a Composite object type */
-export function Composite(T, options) {
-    return CloneType(CompositeResolve(T), options);
+    return Object(properties, options);
 }

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

@@ -11,14 +11,12 @@ import type { TConstructor } from '../constructor/index.mjs';
 import type { TFunction } from '../function/index.mjs';
 import type { TRef } from '../ref/index.mjs';
 import type { TObject, TProperties } from '../object/index.mjs';
-export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, DerefResolve<L>]> : Acc);
+export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TDeref<L>]> : Acc);
 type FromProperties<T extends TProperties> = Evaluate<{
-    [K in keyof T]: DerefResolve<T[K]>;
+    [K in keyof T]: TDeref<T[K]>;
 }>;
 declare function FromProperties(properties: TProperties, references: TSchema[]): TProperties;
-export type DerefResolve<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, DerefResolve<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, DerefResolve<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<DerefResolve<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<DerefResolve<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DerefResolve<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DerefResolve<S>> : T extends TRef<infer S extends TSchema> ? DerefResolve<S> : T;
-export declare function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
-export type TDeref<T extends TSchema> = DerefResolve<T>;
+export type TDeref<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, TDeref<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, TDeref<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<TDeref<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<TDeref<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDeref<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<TDeref<S>> : T extends TRef<infer S extends TSchema> ? TDeref<S> : T;
 /** `[Json]` Creates a dereferenced type */
 export declare function Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
 export {};

package/build/import/type/deref/deref.mjs

@@ -77,7 +77,7 @@ function FromRef(schema, references) {
     return Deref(discard, references);
 }
 // prettier-ignore
-export function DerefResolve(schema, references) {
+function DerefResolve(schema, references) {
     return (IsConstructor(schema) ? FromConstructor(schema, references) :
         IsFunction(schema) ? FromFunction(schema, references) :
             IsIntersect(schema) ? FromIntersect(schema, references) :
@@ -91,6 +91,9 @@ export function DerefResolve(schema, references) {
                                             IsRef(schema) ? FromRef(schema, references) :
                                                 schema);
 }
+// ------------------------------------------------------------------
+// TDeref
+// ------------------------------------------------------------------
 /** `[Json]` Creates a dereferenced type */
 export function Deref(schema, references) {
     return DerefResolve(CloneType(schema), CloneRest(references));

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

@@ -11,14 +11,11 @@ import { type TExcludeFromMappedResult } from './exclude-from-mapped-result.mjs'
 type TExcludeTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
-type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = (Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never);
-type TExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
-    [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K];
+type TExcludeTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (Exclude<Static<L>, Static<R>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never);
+type TExcludeRest<L extends TSchema[], R extends TSchema> = AssertRest<UnionToTuple<{
+    [K in keyof L]: Static<AssertType<L[K]>> extends Static<R> ? never : L[K];
 }[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never;
-type TExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? TExcludeArray<S, U> : T extends U ? TNever : T;
-export type TExclude<T extends TSchema, U extends TSchema> = TExcludeResolve<T, U>;
+export type TExclude<L extends TSchema, R extends TSchema> = (L extends TMappedResult<L> ? TExcludeFromMappedResult<L, R> : L extends TTemplateLiteral ? TExcludeTemplateLiteral<L, R> : L extends TUnion<infer S> ? TExcludeRest<S, R> : L extends R ? TNever : L);
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-export declare function Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
-/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-export declare function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
+export declare function Exclude<L extends TSchema, R extends TSchema>(L: L, R: R, options?: SchemaOptions): TExclude<L, R>;
 export {};

package/build/import/type/exclude/exclude.mjs

@@ -8,24 +8,16 @@ import { ExcludeFromMappedResult } from './exclude-from-mapped-result.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type.mjs';
-// prettier-ignore
-function ExcludeResolve(L, R) {
-    return (IsTemplateLiteral(L) ? ExcludeResolve(TemplateLiteralToUnion(L), R) :
-        IsTemplateLiteral(R) ? ExcludeResolve(L, TemplateLiteralToUnion(R)) :
-            IsUnion(L) ? (() => {
-                const narrowed = L.anyOf.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
-                return (narrowed.length === 1 ? narrowed[0] : Union(narrowed));
-            })() :
-                ExtendsCheck(L, R) !== ExtendsResult.False ? Never() :
-                    L);
+function ExcludeRest(L, R) {
+    const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
+    return excluded.length === 1 ? excluded[0] : Union(excluded);
 }
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-export function Exclude(unionType, excludedMembers, options = {}) {
-    if (IsMappedResult(unionType)) {
-        return ExcludeFromMappedResult(unionType, excludedMembers, options);
-    }
-    else {
-        const E = ExcludeResolve(unionType, excludedMembers);
-        return CloneType(E, options);
-    }
+export function Exclude(L, R, options = {}) {
+    // prettier-ignore
+    return CloneType((IsMappedResult(L) ? ExcludeFromMappedResult(L, R, options) :
+        IsTemplateLiteral(L) ? Exclude(TemplateLiteralToUnion(L), R) :
+            IsTemplateLiteral(R) ? Exclude(L, TemplateLiteralToUnion(R)) :
+                IsUnion(L) ? ExcludeRest(L.anyOf, R) :
+                    ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L), options);
 }

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

@@ -5,19 +5,17 @@ import { type TTemplateLiteral } from '../template-literal/index.mjs';
 import { type TLiteral } from '../literal/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type Static } from '../static/index.mjs';
+import { type TNever } from '../never/index.mjs';
 import { type TUnionEvaluated } from '../union/index.mjs';
 import { type TExtractFromMappedResult } from './extract-from-mapped-result.mjs';
-type TFromTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{
+type TExtractTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
-type TFromTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TFromTemplateLiteralResult<Assert<S, string>> : never;
-type TFromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
-    [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never;
+type TExtractTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = Extract<Static<L>, Static<R>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never;
+type TExtractRest<L extends TSchema[], R extends TSchema> = AssertRest<UnionToTuple<{
+    [K in keyof L]: Static<AssertType<L[K]>> extends Static<R> ? L[K] : never;
 }[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never;
-type TExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? TFromTemplateLiteral<T, U> : T extends TUnion<infer S> ? TFromArray<S, U> : T);
-export type TExtract<T extends TSchema, U extends TSchema> = TExtractResolve<T, U>;
+export type TExtract<L extends TSchema, U extends TSchema> = (L extends TMappedResult ? TExtractFromMappedResult<L, U> : L extends TTemplateLiteral ? TExtractTemplateLiteral<L, U> : L extends TUnion<infer S> ? TExtractRest<S, U> : L extends U ? L : TNever);
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-export declare function Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
-/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-export declare function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
+export declare function Extract<L extends TSchema, R extends TSchema>(L: L, R: R, options?: SchemaOptions): TExtract<L, R>;
 export {};

package/build/import/type/extract/extract.mjs

@@ -8,24 +8,16 @@ import { ExtractFromMappedResult } from './extract-from-mapped-result.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type.mjs';
-// prettier-ignore
-function ExtractResolve(L, R) {
-    return (IsTemplateLiteral(L) ? ExtractResolve(TemplateLiteralToUnion(L), R) :
-        IsTemplateLiteral(R) ? ExtractResolve(L, TemplateLiteralToUnion(R)) :
-            IsUnion(L) ? (() => {
-                const narrowed = L.anyOf.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
-                return (narrowed.length === 1 ? narrowed[0] : Union(narrowed));
-            })() :
-                ExtendsCheck(L, R) !== ExtendsResult.False ? L :
-                    Never());
+function ExtractRest(L, R) {
+    const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
+    return extracted.length === 1 ? extracted[0] : Union(extracted);
 }
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-export function Extract(type, union, options = {}) {
-    if (IsMappedResult(type)) {
-        return ExtractFromMappedResult(type, union, options);
-    }
-    else {
-        const E = ExtractResolve(type, union);
-        return CloneType(E, options);
-    }
+export function Extract(L, R, options = {}) {
+    // prettier-ignore
+    return CloneType((IsMappedResult(L) ? ExtractFromMappedResult(L, R, options) :
+        IsTemplateLiteral(L) ? Extract(TemplateLiteralToUnion(L), R) :
+            IsTemplateLiteral(R) ? Extract(L, TemplateLiteralToUnion(R)) :
+                IsUnion(L) ? ExtractRest(L.anyOf, R) :
+                    ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never()), options);
 }

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

@@ -1,5 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Evaluate } from '../helpers/index.mjs';
+import type { Ensure, Evaluate } from '../helpers/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TIndex } from './indexed.mjs';
 import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
@@ -8,6 +8,6 @@ type TMappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
 };
 type TMappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedIndexPropertyKeys<T, R, Acc & TMappedIndexPropertyKey<T, L>> : Acc);
 type TMappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<TMappedIndexPropertyKeys<T, K['keys']>>;
-export type TIndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>> = (TMappedResult<P>);
+export type TIndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>> = (Ensure<TMappedResult<P>>);
 export declare function IndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -13,7 +13,7 @@ import { type TUnionEvaluated } from '../union/index.mjs';
 import { type TIndexPropertyKeys } from './indexed-property-keys.mjs';
 import { type TIndexFromMappedKey } from './indexed-from-mapped-key.mjs';
 import { type TIndexFromMappedResult } from './indexed-from-mapped-result.mjs';
-type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Acc, Assert<TFromKey<L, K>, TSchema>]> : Acc);
+type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Acc, Assert<TIndexFromPropertyKey<L, K>, TSchema>]> : Acc);
 type TFromIntersectRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? TFromIntersectRest<R, [...Acc]> : TFromIntersectRest<R, [...Acc, L]> : Acc);
 type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<T, K>>>);
 type TFromUnionRest<T extends TSchema[]> = T;
@@ -22,9 +22,11 @@ type TFromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T
 type TFromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
 type AssertPropertyKey<T> = Assert<T, string | number>;
 type TFromProperty<T extends TProperties, K extends PropertyKey> = (K extends keyof T ? T[K] : `${AssertPropertyKey<K>}` extends `${AssertPropertyKey<keyof T>}` ? T[AssertPropertyKey<K>] : TNever);
-type TFromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? TFromKey<S, K> : T extends TIntersect<infer S> ? TFromIntersect<S, K> : T extends TUnion<infer S> ? TFromUnion<S, K> : T extends TTuple<infer S> ? TFromTuple<S, K> : T extends TArray<infer S> ? TFromArray<S, K> : T extends TObject<infer S> ? TFromProperty<S, K> : TNever);
-type TFromKeys<T extends TSchema, K extends PropertyKey[], Acc extends TSchema[] = []> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TFromKeys<T, R, [...Acc, Assert<TFromKey<T, L>, TSchema>]> : Acc);
-type FromSchema<T extends TSchema, K extends PropertyKey[]> = (TUnionEvaluated<TFromKeys<T, K>>);
+export type TIndexFromPropertyKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? TIndexFromPropertyKey<S, K> : T extends TIntersect<infer S> ? TFromIntersect<S, K> : T extends TUnion<infer S> ? TFromUnion<S, K> : T extends TTuple<infer S> ? TFromTuple<S, K> : T extends TArray<infer S> ? TFromArray<S, K> : T extends TObject<infer S> ? TFromProperty<S, K> : TNever);
+export declare function IndexFromPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): TIndexFromPropertyKey<T, K>;
+export type TIndexFromPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TSchema[] = []> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TIndexFromPropertyKeys<T, R, [...Acc, Assert<TIndexFromPropertyKey<T, L>, TSchema>]> : Acc);
+export declare function IndexFromPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TIndexFromPropertyKeys<T, K>;
+type FromSchema<T extends TSchema, K extends PropertyKey[]> = (TUnionEvaluated<TIndexFromPropertyKeys<T, K>>);
 declare function FromSchema<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromSchema<T, K>;
 export type TIndex<T extends TSchema, K extends PropertyKey[]> = (FromSchema<T, K>);
 /** `[Json]` Returns an Indexed property type for the given keys */

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

@@ -11,7 +11,7 @@ import { IndexFromMappedResult } from './indexed-from-mapped-result.mjs';
 import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/type.mjs';
 // prettier-ignore
 function FromRest(T, K) {
-    return T.map(L => FromKey(L, K));
+    return T.map(L => IndexFromPropertyKey(L, K));
 }
 // prettier-ignore
 function FromIntersectRest(T) {
@@ -46,7 +46,7 @@ function FromProperty(T, K) {
     return (K in T ? T[K] : Never());
 }
 // prettier-ignore
-function FromKey(T, K) {
+export function IndexFromPropertyKey(T, K) {
     return (IsIntersect(T) ? FromIntersect(T.allOf, K) :
         IsUnion(T) ? FromUnion(T.anyOf, K) :
             IsTuple(T) ? FromTuple(T.items ?? [], K) :
@@ -55,12 +55,12 @@ function FromKey(T, K) {
                         Never());
 }
 // prettier-ignore
-function FromKeys(T, K) {
-    return K.map(L => FromKey(T, L));
+export function IndexFromPropertyKeys(T, K) {
+    return K.map(L => IndexFromPropertyKey(T, L));
 }
 // prettier-ignore
 function FromSchema(T, K) {
-    return (UnionEvaluated(FromKeys(T, K)));
+    return (UnionEvaluated(IndexFromPropertyKeys(T, K)));
 }
 /** `[Json]` Returns an Indexed property type for the given keys */
 export function Index(T, K, options = {}) {

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

@@ -1,11 +1,12 @@
 import type { SchemaOptions } from '../schema/index.mjs';
+import type { Ensure, Evaluate } from '../helpers/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TKeyOf } from './keyof.mjs';
 type TFromProperties<K extends TProperties> = ({
     [K2 in keyof K]: TKeyOf<K[K2]>;
 });
-type TFromMappedResult<R extends TMappedResult> = (TFromProperties<R['properties']>);
-export type TKeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (TMappedResult<P>);
+type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
+export type TKeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
 export declare function KeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -7,10 +7,10 @@ import { type TNumber } from '../number/index.mjs';
 import { type TKeyOfPropertyKeys } from './keyof-property-keys.mjs';
 import { type TUnionEvaluated } from '../union/index.mjs';
 import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
-type TFromPropertyKeys<T extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? L extends '[number]' ? TFromPropertyKeys<R, [...Acc, TNumber]> : TFromPropertyKeys<R, [...Acc, TLiteral<Assert<L, TLiteralValue>>]> : Acc);
-export type TKeyOf<T extends TSchema, K extends PropertyKey[] = TKeyOfPropertyKeys<T>, S extends TSchema[] = TFromPropertyKeys<K>, U = TUnionEvaluated<S>> = (Ensure<U>);
+export type TKeyOfPropertyKeysToRest<T extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? L extends '[number]' ? TKeyOfPropertyKeysToRest<R, [...Acc, TNumber]> : TKeyOfPropertyKeysToRest<R, [...Acc, TLiteral<Assert<L, TLiteralValue>>]> : Acc);
+export declare function KeyOfPropertyKeysToRest<T extends PropertyKey[]>(T: [...T]): TKeyOfPropertyKeysToRest<T>;
+export type TKeyOf<T extends TSchema, K extends PropertyKey[] = TKeyOfPropertyKeys<T>, S extends TSchema[] = TKeyOfPropertyKeysToRest<K>, U = TUnionEvaluated<S>> = (Ensure<U>);
 /** `[Json]` Creates a KeyOf type */
 export declare function KeyOf<T extends TMappedResult>(T: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
 /** `[Json]` Creates a KeyOf type */
 export declare function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>;
-export {};

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

@@ -9,7 +9,7 @@ import { KeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 import { IsMappedResult } from '../guard/type.mjs';
 // prettier-ignore
-function FromPropertyKeys(T) {
+export function KeyOfPropertyKeysToRest(T) {
     return T.map(L => L === '[number]' ? Number() : Literal(L));
 }
 /** `[Json]` Creates a KeyOf type */
@@ -19,7 +19,7 @@ export function KeyOf(T, options = {}) {
     }
     else {
         const K = KeyOfPropertyKeys(T);
-        const S = FromPropertyKeys(K);
+        const S = KeyOfPropertyKeysToRest(K);
         const U = UnionEvaluated(S);
         return CloneType(U, options);
     }

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

@@ -33,12 +33,12 @@ type FromProperties<K extends PropertyKey, T extends TProperties, R extends TPro
 declare function FromProperties<K extends PropertyKey, T extends TProperties>(K: K, T: T): FromProperties<K, T>;
 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> ? TFromMappedResult<K, P> : T extends TMappedKey<infer P> ? TFromMappedKey<K, P> : T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<K, S>, FromSchemaType<K, R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<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<TFromRest<K, S>> : T extends TUnion<infer S> ? TUnion<TFromRest<K, S>> : T extends TTuple<infer S> ? TTuple<TFromRest<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, Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? FromMappedFunctionReturnType<R, T, Acc & {
+export type TMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema, Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedFunctionReturnType<R, T, Acc & {
     [_ in L]: FromSchemaType<L, T>;
 }> : Acc);
-declare function FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T, Acc?: TProperties): FromMappedFunctionReturnType<K, T>;
+export declare function MappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T, Acc?: TProperties): TMappedFunctionReturnType<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 type TMapped<K extends PropertyKey[], F extends TMappedFunction<K>, R extends TProperties = Evaluate<TMappedFunctionReturnType<K, ReturnType<F>>>> = Ensure<TObject<R>>;
 /** `[Json]` Creates a Mapped object type */
 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;
 /** `[Json]` Creates a Mapped object type */

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

@@ -85,7 +85,7 @@ function FromSchemaType(K, T) {
                                                             T);
 }
 // prettier-ignore
-function FromMappedFunctionReturnType(K, T, Acc = {}) {
+export function MappedFunctionReturnType(K, T, Acc = {}) {
     return K.reduce((Acc, L) => {
         return { ...Acc, [L]: FromSchemaType(L, T) };
     }, {});
@@ -94,6 +94,6 @@ function FromMappedFunctionReturnType(K, T, Acc = {}) {
 export function Mapped(key, map, options = {}) {
     const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
     const RT = map({ [Kind]: 'MappedKey', keys: K });
-    const R = FromMappedFunctionReturnType(K, RT);
+    const R = MappedFunctionReturnType(K, RT);
     return CloneType(Object(R), options);
 }

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

@@ -1,11 +1,12 @@
 import type { SchemaOptions } from '../schema/index.mjs';
+import type { Ensure, Evaluate } from '../helpers/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TOmit } from './omit.mjs';
 type TFromProperties<P extends TProperties, K extends PropertyKey[]> = ({
     [K2 in keyof P]: TOmit<P[K2], K>;
 });
-type TFromMappedResult<R extends TMappedResult, K extends PropertyKey[]> = (TFromProperties<R['properties'], K>);
-export type TOmitFromMappedResult<T extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<T, K>> = (TMappedResult<P>);
+type TFromMappedResult<R extends TMappedResult, K extends PropertyKey[]> = (Evaluate<TFromProperties<R['properties'], K>>);
+export type TOmitFromMappedResult<T extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<T, K>> = (Ensure<TMappedResult<P>>);
 export declare function OmitFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -8,12 +8,10 @@ import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TIndexPropertyKeys } from '../indexed/index.mjs';
 import { type TOmitFromMappedKey } from './omit-from-mapped-key.mjs';
 import { type TOmitFromMappedResult } from './omit-from-mapped-result.mjs';
-type TFromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, K, [...Acc, TOmitResolve<L, K>]> : Acc);
-type TFromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, K, [...Acc, TOmitResolve<L, K>]> : Acc);
+type TFromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, K, [...Acc, TOmit<L, K>]> : Acc);
+type TFromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, K, [...Acc, TOmit<L, K>]> : Acc);
 type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Omit<T, I>>;
-export type TOmitResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<TOmitResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<TFromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<TFromUnion<S, K>> : T extends TObject<infer S> ? TObject<TFromProperties<S, K>> : TObject<{}>;
-export declare function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TOmitResolve<T, K>;
-export type TOmit<T extends TSchema, K extends PropertyKey[]> = TOmitResolve<T, K>;
+export type TOmit<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> : T extends TIntersect<infer S> ? TIntersect<TFromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<TFromUnion<S, K>> : T extends TObject<infer S> ? TObject<TFromProperties<S, K>> : TObject<{}>;
 /** `[Json]` Constructs a type whose keys are omitted from the given type */
 export declare function Omit<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TOmitFromMappedResult<T, K>;
 /** `[Json]` Constructs a type whose keys are omitted from the given type */

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

@@ -33,8 +33,11 @@ function FromProperties(T, K) {
         return FromProperty(T, K2);
     }, T);
 }
+// ------------------------------------------------------------------
+// OmitResolve
+// ------------------------------------------------------------------
 // prettier-ignore
-export function OmitResolve(T, K) {
+function OmitResolve(T, K) {
     return (IsIntersect(T) ? Intersect(FromIntersect(T.allOf, K)) :
         IsUnion(T) ? Union(FromUnion(T.anyOf, K)) :
             IsObject(T) ? Object(FromProperties(T.properties, K)) :

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

@@ -1,11 +1,12 @@
 import type { SchemaOptions } from '../schema/index.mjs';
+import type { Ensure, Evaluate } from '../helpers/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TPartial } from './partial.mjs';
 type TFromProperties<P extends TProperties> = ({
     [K2 in keyof P]: TPartial<P[K2]>;
 });
-type TFromMappedResult<R extends TMappedResult> = (TFromProperties<R['properties']>);
-export type TPartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (TMappedResult<P>);
+type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
+export type TPartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
 export declare function PartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -1,11 +1,12 @@
 import type { SchemaOptions } from '../schema/index.mjs';
+import type { Ensure, Evaluate } from '../helpers/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TPick } from './pick.mjs';
 type TFromProperties<P extends TProperties, K extends PropertyKey[]> = ({
     [K2 in keyof P]: TPick<P[K2], K>;
 });
-type TFromMappedResult<R extends TMappedResult, K extends PropertyKey[]> = (TFromProperties<R['properties'], K>);
-export type TPickFromMappedResult<T extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<T, K>> = (TMappedResult<P>);
+type TFromMappedResult<R extends TMappedResult, K extends PropertyKey[]> = (Evaluate<TFromProperties<R['properties'], K>>);
+export type TPickFromMappedResult<T extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<T, K>> = (Ensure<TMappedResult<P>>);
 export declare function PickFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options: SchemaOptions): TMappedResult<P>;
 export {};