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

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

package/build/import/type/pick/pick-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 TPick } from './pick.mjs';
+type FromPropertyKey<T extends TSchema, K extends PropertyKey> = {
+    [_ in K]: TPick<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 TPickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = FromMappedKey<T, K>> = (TMappedResult<P>);
+export declare function PickFromMappedKey<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/pick/pick-from-mapped-key.mjs

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

package/build/import/type/pick/pick.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 TPickMappedResult } from './pick-mapped-result.mjs';
+import { type TPickFromMappedKey } from './pick-from-mapped-key.mjs';
 type FromIntersect<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PickResolve<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[]] ? [PickResolve<L, K>, ...FromUnion<R, K>] : [];
@@ -16,7 +16,7 @@ declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(
 export type PickResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<PickResolve<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 PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): PickResolve<T, K>;
 export type TPick<T extends TSchema, K extends PropertyKey[]> = PickResolve<T, K>;
-export declare function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickMappedResult<T, K>;
+export declare function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<T, K>;
 export declare function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
 export declare function Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
 export {};

package/build/import/type/pick/pick.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 { PickMappedResult } from './pick-mapped-result.mjs';
+import { PickFromMappedKey } from './pick-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) => PickResolve(T, K));
@@ -26,7 +26,7 @@ export function PickResolve(T, K) {
 }
 export function Pick(T, K, options = {}) {
     if (IsMappedKeyType(K)) {
-        return PickMappedResult(T, K);
+        return PickFromMappedKey(T, K, options);
     }
     else {
         const I = IsSchemaType(K) ? IndexPropertyKeys(K) : K;

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

@@ -40,7 +40,6 @@ declare function FromIntegerKey<K extends TInteger, T extends TSchema>(_: K, T:
 type FromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
 declare function FromNumberKey<K extends TNumber, T extends TSchema>(_: K, T: T): FromIntegerKey<K, T>;
 export type RecordResolve<K extends TSchema, T extends TSchema> = K extends TEnum<infer S> ? FromEnumKey<S, T> : K extends TUnion<infer S> ? FromUnionKey<S, T> : K extends TTemplateLiteral ? FromTemplateLiteralKey<K, T> : K extends TLiteral<infer S> ? FromLiteralKey<S, T> : K extends TInteger ? FromIntegerKey<K, T> : K extends TNumber ? FromNumberKey<K, T> : K extends TString ? FromStringKey<K, T> : TNever;
-export declare function RecordResolve<K extends TSchema, T extends TSchema>(K: K, T: T): RecordResolve<K, T>;
 export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Record';
     static: Record<Assert<Static<K>, string | number>, Static<T, this['params']>>;

package/build/import/type/record/record.mjs

@@ -37,7 +37,7 @@ function FromIntegerKey(_, T) {
 function FromNumberKey(_, T) {
     return FromPattern(PatternNumberExact, T);
 }
-export function RecordResolve(K, T) {
+function RecordResolve(K, T) {
     return (IsUnionType(K) ? FromUnionKey(K.anyOf, T) :
         IsTemplateLiteralType(K) ? FromTemplateLiteralKey(K, T) :
             IsLiteralType(K) ? FromLiteralKey(K.const, T) :

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

@@ -6,9 +6,10 @@ export interface TThis extends TSchema {
     static: this['params'][0];
     $ref: string;
 }
-export type RecursiveResolve<T extends TSchema> = Static<T, [RecursiveResolve<T>]>;
+type RecursiveStatic<T extends TSchema> = Static<T, [RecursiveStatic<T>]>;
 export interface TRecursive<T extends TSchema> extends TSchema {
     [Hint]: 'Recursive';
-    static: RecursiveResolve<T>;
+    static: RecursiveStatic<T>;
 }
 export declare function Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
+export {};

package/build/import/type/recursive/recursive.mjs

@@ -7,9 +7,5 @@ export function Recursive(callback, options = {}) {
         options.$id = `T${Ordinal++}`;
     const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` });
     thisType.$id = options.$id;
-    return CloneType({
-        ...options,
-        [Hint]: 'Recursive',
-        ...thisType,
-    });
+    return CloneType({ ...options, [Hint]: 'Recursive', ...thisType });
 }

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

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

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

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

package/build/import/type/required/required-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 TRequired } from './required.mjs';
+type FromProperties<K extends TProperties> = ({
+    [K2 in keyof K]: TRequired<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 TRequiredFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>> = (TMappedResult<P>);
+export declare function RequiredFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
+export {};

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

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

package/build/import/type/required/required.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 TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
+import { type TRequiredFromMappedResult } from './required-from-mapped-result.mjs';
 type FromIntersect<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [RequiredResolve<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[]] ? [RequiredResolve<L>, ...FromUnion<R>] : []);
@@ -15,8 +17,9 @@ type FromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : T[K] extends (TReadonly<infer S>) ? TReadonly<S> : T[K] extends (TOptional<infer S>) ? S : T[K];
 }>;
 declare function FromProperties<T extends TProperties>(T: T): TProperties;
-export type RequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<RequiredResolve<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 RequiredResolve<T extends TSchema>(T: T): RequiredResolve<T>;
+type RequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<RequiredResolve<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 RequiredResolve<T extends TSchema>(T: T): RequiredResolve<T>;
 export type TRequired<T extends TSchema> = RequiredResolve<T>;
+export declare function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
 export declare function Required<T extends TSchema>(T: T, options?: SchemaOptions): TRequired<T>;
 export {};

package/build/import/type/required/required.mjs

@@ -4,7 +4,8 @@ import { Object } from '../object/index.mjs';
 import { OptionalKind, TransformKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
-import { TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType } from '../guard/type.mjs';
+import { RequiredFromMappedResult } from './required-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
@@ -22,14 +23,19 @@ function FromProperties(T) {
         return { ...Acc, [K]: Discard(T[K], [OptionalKind]) };
     }, {});
 }
-export function RequiredResolve(T) {
+function RequiredResolve(T) {
     return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf)) :
         IsUnionType(T) ? Union(FromUnion(T.anyOf)) :
             IsObjectType(T) ? Object(FromProperties(T.properties)) :
                 Object({}));
 }
 export function Required(T, options = {}) {
-    const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(RequiredResolve(T), options);
-    return { ...D, ...R };
+    if (IsMappedResultType(T)) {
+        return RequiredFromMappedResult(T, options);
+    }
+    else {
+        const D = Discard(T, [TransformKind, '$id', 'required']);
+        const R = CloneType(RequiredResolve(T), options);
+        return { ...D, ...R };
+    }
 }

package/build/import/type/template-literal/syntax.d.mts

@@ -1,19 +1,19 @@
-import type { Ensure, Assert, Trim } from '../helpers/index.mjs';
+import type { Assert, Trim } from '../helpers/index.mjs';
 import type { TTemplateLiteralKind, TTemplateLiteral } from './index.mjs';
 import { type TLiteral } from '../literal/index.mjs';
 import { type TBoolean } from '../boolean/index.mjs';
 import { type TBigInt } from '../bigint/index.mjs';
 import { type TNumber } from '../number/index.mjs';
 import { type TString } from '../string/index.mjs';
-import { UnionResolve } from '../union/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
 declare function FromUnion(syntax: string): IterableIterator<TTemplateLiteralKind>;
 declare function FromTerminal(syntax: string): IterableIterator<TTemplateLiteralKind>;
 type FromUnionLiteral<T extends string> = T extends `${infer L}|${infer R}` ? [TLiteral<Trim<L>>, ...FromUnionLiteral<R>] : T extends `${infer L}` ? [TLiteral<Trim<L>>] : [
 ];
-type FromUnion<T extends string> = UnionResolve<FromUnionLiteral<T>>;
+type FromUnion<T extends string> = UnionEvaluated<FromUnionLiteral<T>>;
 type FromTerminal<T extends string> = T extends 'boolean' ? TBoolean : T extends 'bigint' ? TBigInt : T extends 'number' ? TNumber : T extends 'string' ? TString : FromUnion<T>;
 type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$${infer R}` ? [TLiteral<L>, ...FromString<R>] : T extends `${infer L}` ? [TLiteral<L>] : [
 ];
-export type TemplateLiteralSyntax<T extends string> = Ensure<TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>>;
+export type TemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
 export declare function TemplateLiteralSyntax(syntax: string): TTemplateLiteralKind[];
 export {};

package/build/import/type/template-literal/template-literal.d.mts

@@ -12,14 +12,14 @@ import type { Static } from '../static/index.mjs';
 import { TemplateLiteralSyntax } from './syntax.mjs';
 import { EmptyString } from '../helpers/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-type TemplateLiteralResolveConst<T, Acc extends string> = T extends TUnion<infer U> ? {
-    [K in keyof U]: TemplateLiteralResolve<Assert<[U[K]], TTemplateLiteralKind[]>, Acc>;
+type TemplateLiteralStaticKind<T, Acc extends string> = T extends TUnion<infer U> ? {
+    [K in keyof U]: TemplateLiteralStatic<Assert<[U[K]], TTemplateLiteralKind[]>, Acc>;
 }[number] : T extends TTemplateLiteral ? `${Static<T>}` : T extends TLiteral<infer U> ? `${U}` : T extends TString ? `${string}` : T extends TNumber ? `${number}` : T extends TBigInt ? `${bigint}` : T extends TBoolean ? `${boolean}` : never;
-export type TemplateLiteralResolve<T extends TTemplateLiteralKind[], Acc extends string> = T extends [infer L, ...infer R] ? `${TemplateLiteralResolveConst<L, Acc>}${TemplateLiteralResolve<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
+type TemplateLiteralStatic<T extends TTemplateLiteralKind[], Acc extends string> = T extends [infer L, ...infer R] ? `${TemplateLiteralStaticKind<L, Acc>}${TemplateLiteralStatic<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
 export type TTemplateLiteralKind = TTemplateLiteral | TUnion | TLiteral | TInteger | TNumber | TBigInt | TString | TBoolean | TNever;
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
     [Kind]: 'TemplateLiteral';
-    static: TemplateLiteralResolve<T, EmptyString>;
+    static: TemplateLiteralStatic<T, EmptyString>;
     type: 'string';
     pattern: string;
 }

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

@@ -14,15 +14,16 @@ export declare class TransformEncodeBuilder<T extends TSchema, D extends Transfo
     private EncodeSchema;
     Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(encode: E): TTransform<T, ReturnType<D>>;
 }
+type TransformStatic<T extends TSchema, P extends unknown[] = []> = T extends TTransform<infer _, infer S> ? S : Static<T, P>;
 export type TransformFunction<T = any, U = any> = (value: T) => U;
 export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
     Decode: TransformFunction<StaticDecode<I>, O>;
     Encode: TransformFunction<O, StaticDecode<I>>;
 }
-export type TTransformResolve<T extends TSchema, P extends unknown[] = []> = T extends TTransform<infer _, infer S> ? S : Static<T, P>;
 export interface TTransform<I extends TSchema = TSchema, O extends unknown = unknown> extends TSchema {
-    static: TTransformResolve<I, this['params']>;
+    static: TransformStatic<I, this['params']>;
     [TransformKind]: TransformOptions<I, O>;
     [key: string]: any;
 }
 export declare function Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;
+export {};

package/build/import/type/transform/transform.mjs

@@ -1,6 +1,6 @@
-import { TTransform as IsTransform } from '../guard/type.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { TransformKind } from '../symbols/index.mjs';
+import { TTransform as IsTransform } from '../guard/type.mjs';
 export class TransformDecodeBuilder {
     schema;
     constructor(schema) {

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

@@ -1,11 +1,11 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Static } from '../static/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-type FromRest<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...FromRest<R, P>] : [];
-type TupleResolve<T extends TSchema[], P extends unknown[], R extends unknown[] = FromRest<T, P>> = R;
+type TupleStaticRest<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TupleStaticRest<R, P>] : [];
+type TupleStatic<T extends TSchema[], P extends unknown[], R extends unknown[] = TupleStaticRest<T, P>> = R;
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
-    static: TupleResolve<T, this['params']>;
+    static: TupleStatic<T, this['params']>;
     type: 'array';
     items?: T;
     additionalItems?: false;

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

@@ -5,14 +5,14 @@ import { type TComposite } from '../composite/index.mjs';
 import { type TConst } from '../const/index.mjs';
 import { type TDeref } from '../deref/index.mjs';
 import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index.mjs';
-import { type TExclude } from '../exclude/index.mjs';
-import { type TExtends, type TExtendsMappedResult, type TExtendsMappedResultFromResult } from '../extends/index.mjs';
-import { type TExtract } from '../extract/index.mjs';
-import { TIndex, type TIndexPropertyKeys, type TIndexMappedResult } from '../indexed/index.mjs';
+import { type TExclude, type TExcludeFromMappedResult } from '../exclude/index.mjs';
+import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index.mjs';
+import { type TExtract, type TExtractFromMappedResult } from '../extract/index.mjs';
+import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from '../indexed/index.mjs';
 import { type IntegerOptions, type TInteger } from '../integer/index.mjs';
-import { type IntersectOptions, type IntersectResolve } from '../intersect/index.mjs';
+import { Intersect, type IntersectOptions } from '../intersect/index.mjs';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index.mjs';
-import { type TKeyOf } from '../keyof/index.mjs';
+import { type TKeyOf, type TKeyOfFromMappedResult } from '../keyof/index.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TMappedFunction, type TMapped, type TMappedResult } from '../mapped/index.mjs';
 import { type TNever } from '../never/index.mjs';
@@ -21,23 +21,23 @@ import { type TNull } from '../null/index.mjs';
 import { type TMappedKey } from '../mapped/index.mjs';
 import { type TNumber, type NumberOptions } from '../number/index.mjs';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
-import { type TOmit, type TOmitMappedResult } from '../omit/index.mjs';
+import { type TOmit, type TOmitFromMappedKey } from '../omit/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
-import { type TPartial } from '../partial/index.mjs';
-import { type TPick, type TPickMappedResult } from '../pick/index.mjs';
+import { type TPartial, type TPartialFromMappedResult } from '../partial/index.mjs';
+import { type TPick, type TPickFromMappedKey } from '../pick/index.mjs';
 import { type TReadonly } from '../readonly/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type RecordResolve } from '../record/index.mjs';
 import { type TRecursive, type TThis } from '../recursive/index.mjs';
 import { type TRef } from '../ref/index.mjs';
-import { type TRequired } from '../required/index.mjs';
+import { type TRequired, type TRequiredFromMappedResult } from '../required/index.mjs';
 import { type TRest } from '../rest/index.mjs';
 import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
 import { type TString, type StringOptions } from '../string/index.mjs';
 import { type TTemplateLiteral, type TTemplateLiteralKind, type TemplateLiteralSyntax } from '../template-literal/index.mjs';
 import { TransformDecodeBuilder } from '../transform/index.mjs';
 import { type TTuple } from '../tuple/index.mjs';
-import { type UnionResolve } from '../union/index.mjs';
+import { Union } from '../union/index.mjs';
 import { type TUnknown } from '../unknown/index.mjs';
 import { type TUnsafe, type UnsafeOptions } from '../unsafe/index.mjs';
 export declare class JsonTypeBuilder {
@@ -53,16 +53,19 @@ export declare class JsonTypeBuilder {
     Const<T>(value: T, options?: SchemaOptions): TConst<T>;
     Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
     Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;
-    Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsMappedResultFromResult<L, R, T, F>;
-    Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsMappedResult<L, R, T, F>;
-    Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
+    Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
     Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
+    Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>;
+    Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedKey<L, R, T, F>;
+    Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
+    Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
     Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
-    Index<T extends TSchema, K extends TMappedKey>(T: T, K: K): TIndexMappedResult<T, K>;
+    Index<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedKey<T, K>;
     Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
     Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;
     Integer(options?: IntegerOptions): TInteger;
-    Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): IntersectResolve<T>;
+    Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T>;
+    KeyOf<T extends TMappedResult>(schema: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
     KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
     Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
     Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TLowercase<T>;
@@ -73,18 +76,20 @@ export declare class JsonTypeBuilder {
     Null(options?: SchemaOptions): TNull;
     Number(options?: NumberOptions): TNumber;
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitMappedResult<T, K>;
+    Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitFromMappedKey<T, K>;
     Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
     Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
+    Partial<T extends TMappedResult>(T: T, options?: ObjectOptions): TPartialFromMappedResult<T>;
     Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
-    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickMappedResult<T, K>;
+    Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<T, K>;
     Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
     Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
     Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordResolve<K, T>;
     Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
     Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
     Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
-    Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
+    Required<T extends TMappedResult>(T: T, options?: ObjectOptions): TRequiredFromMappedResult<T>;
+    Required<T extends TSchema>(schema: T, options?: ObjectOptions): TRequired<T>;
     Rest<T extends TSchema>(schema: T): TRest<T>;
     String(options?: StringOptions): TString;
     TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
@@ -92,7 +97,7 @@ export declare class JsonTypeBuilder {
     Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;
     Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
     Uncapitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TUncapitalize<T>;
-    Union<T extends TSchema[]>(schemas: [...T], options?: SchemaOptions): UnionResolve<T>;
+    Union<T extends TSchema[]>(schemas: [...T], options?: SchemaOptions): Union<T>;
     Unknown(options?: SchemaOptions): TUnknown;
     Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
     Uppercase<T extends TSchema>(schema: T, options?: SchemaOptions): TUppercase<T>;

package/build/import/type/type/json.mjs

@@ -76,12 +76,12 @@ export class JsonTypeBuilder {
     Enum(item, options = {}) {
         return Enum(item, options);
     }
-    Extends(L, R, T, F, options = {}) {
-        return Extends(L, R, T, F, options);
-    }
     Exclude(unionType, excludedMembers, options = {}) {
         return Exclude(unionType, excludedMembers, options);
     }
+    Extends(L, R, T, F, options = {}) {
+        return Extends(L, R, T, F, options);
+    }
     Extract(type, union, options = {}) {
         return Extract(type, union, options);
     }

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

@@ -1 +1,3 @@
+export * from './union-evaluated.mjs';
+export * from './union-type.mjs';
 export * from './union.mjs';

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

@@ -1 +1,3 @@
+export * from './union-evaluated.mjs';
+export * from './union-type.mjs';
 export * from './union.mjs';

package/build/import/type/union/union-create.d.mts

@@ -0,0 +1,3 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { TUnion } from './union-type.mjs';
+export declare function UnionCreate<T extends TSchema[]>(T: [...T], options: SchemaOptions): TUnion<T>;

package/build/import/type/union/union-create.mjs

@@ -0,0 +1,5 @@
+import { CloneRest } from '../clone/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+export function UnionCreate(T, options) {
+    return { ...options, [Kind]: 'Union', anyOf: CloneRest(T) };
+}