@sinclair/typebox 0.32.9 → 0.32.11

package/build/import/index.d.mts

@@ -19,9 +19,9 @@ export { ConstructorParameters, type TConstructorParameters } from './type/const
 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 { Exclude, type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from './type/exclude/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 { Extract, type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from './type/extract/index.mjs';
 export { Function, type TFunction } from './type/function/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';
@@ -57,7 +57,7 @@ export { type Static, type StaticDecode, type StaticEncode, type TDecodeType, ty
 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 } from './type/symbol/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 { TemplateLiteral, TemplateLiteralSyntax, TemplateLiteralGenerate, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralToUnion, IsTemplateLiteralFinite, TemplateLiteralExpressionGenerate, IsTemplateLiteralExpressionFinite, type TTemplateLiteral, type TTemplateLiteralSyntax, type TTemplateLiteralGenerate, type TTemplateLiteralKind, type TTemplateLiteralToUnion, 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

@@ -70,7 +70,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, TemplateLiteralSyntax, TemplateLiteralGenerate, TemplateLiteralParse, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralExpressionGenerate, IsTemplateLiteralExpressionFinite, } from './type/template-literal/index.mjs';
+export { TemplateLiteral, TemplateLiteralSyntax, TemplateLiteralGenerate, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralToUnion, 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/exclude/exclude-from-mapped-result.d.mts

@@ -1,4 +1,4 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TExclude } from './exclude.mjs';
@@ -7,5 +7,5 @@ type TFromProperties<K extends TProperties, T extends TSchema> = ({
 });
 type TFromMappedResult<R extends TMappedResult, T extends TSchema> = (TFromProperties<R['properties'], T>);
 export type TExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>> = (TMappedResult<P>);
-export declare function ExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T, options: SchemaOptions): TMappedResult<P>;
+export declare function ExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T): TMappedResult<P>;
 export {};

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

@@ -1,17 +1,17 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Exclude } from './exclude.mjs';
 // prettier-ignore
-function FromProperties(P, U, options) {
+function FromProperties(P, U) {
     return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Exclude(P[K2], U, options) };
+        return { ...Acc, [K2]: Exclude(P[K2], U) };
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(R, T, options) {
-    return FromProperties(R.properties, T, options);
+function FromMappedResult(R, T) {
+    return FromProperties(R.properties, T);
 }
 // prettier-ignore
-export function ExcludeFromMappedResult(R, T, options) {
-    const P = FromMappedResult(R, T, options);
+export function ExcludeFromMappedResult(R, T) {
+    const P = FromMappedResult(R, T);
     return MappedResult(P);
 }

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

@@ -0,0 +1,5 @@
+import type { TSchema } from '../schema/index.mjs';
+import { TExclude } from './exclude.mjs';
+import { type TTemplateLiteral, type TTemplateLiteralToUnion } from '../template-literal/index.mjs';
+export type TExcludeFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (TExclude<TTemplateLiteralToUnion<L>, R>);
+export declare function ExcludeFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema>(L: L, R: R): TExcludeFromTemplateLiteral<L, R>;

package/build/import/type/exclude/exclude-from-template-literal.mjs

@@ -0,0 +1,5 @@
+import { Exclude } from './exclude.mjs';
+import { TemplateLiteralToUnion } from '../template-literal/index.mjs';
+export function ExcludeFromTemplateLiteral(L, R) {
+    return Exclude(TemplateLiteralToUnion(L), R);
+}

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

@@ -1,21 +1,21 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { UnionToTuple, AssertRest, AssertType, Assert } from '../helpers/index.mjs';
+import type { UnionToTuple, AssertRest, AssertType } from '../helpers/index.mjs';
 import type { TMappedResult } from '../mapped/index.mjs';
 import { type TTemplateLiteral } from '../template-literal/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TNever } from '../never/index.mjs';
-import { type TLiteral } from '../literal/index.mjs';
 import { type Static } from '../static/index.mjs';
 import { type TUnionEvaluated } from '../union/index.mjs';
 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<L extends TTemplateLiteral, R extends TSchema> = (Exclude<Static<L>, Static<R>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never);
+import { type TExcludeFromTemplateLiteral } from './exclude-from-template-literal.mjs';
 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;
-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);
+export type TExclude<L extends TSchema, R extends TSchema> = (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 TSchema, R extends TSchema>(L: L, R: R, options?: SchemaOptions): TExclude<L, R>;
+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 TTemplateLiteral, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromTemplateLiteral<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 {};

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

@@ -1,9 +1,9 @@
-import { TemplateLiteralToUnion } from '../template-literal/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Never } from '../never/index.mjs';
 import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { ExcludeFromMappedResult } from './exclude-from-mapped-result.mjs';
+import { ExcludeFromTemplateLiteral } from './exclude-from-template-literal.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -14,10 +14,12 @@ function ExcludeRest(L, R) {
 }
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
 export function Exclude(L, R, options = {}) {
+    // overloads
+    if (IsTemplateLiteral(L))
+        return CloneType(ExcludeFromTemplateLiteral(L, R), options);
+    if (IsMappedResult(L))
+        return CloneType(ExcludeFromMappedResult(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);
+    return CloneType(IsUnion(L) ? ExcludeRest(L.anyOf, R) :
+        ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
 }

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

@@ -1,2 +1,3 @@
 export * from './exclude-from-mapped-result.mjs';
+export * from './exclude-from-template-literal.mjs';
 export * from './exclude.mjs';

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

@@ -1,2 +1,3 @@
 export * from './exclude-from-mapped-result.mjs';
+export * from './exclude-from-template-literal.mjs';
 export * from './exclude.mjs';

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

@@ -1,4 +1,4 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TExtract } from './extract.mjs';
@@ -7,5 +7,5 @@ type TFromProperties<P extends TProperties, T extends TSchema> = ({
 });
 type TFromMappedResult<R extends TMappedResult, T extends TSchema> = (TFromProperties<R['properties'], T>);
 export type TExtractFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>> = (TMappedResult<P>);
-export declare function ExtractFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T, options: SchemaOptions): TMappedResult<P>;
+export declare function ExtractFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T): TMappedResult<P>;
 export {};

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

@@ -1,17 +1,17 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Extract } from './extract.mjs';
 // prettier-ignore
-function FromProperties(P, T, options) {
+function FromProperties(P, T) {
     return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Extract(P[K2], T, options) };
+        return { ...Acc, [K2]: Extract(P[K2], T) };
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(R, T, options) {
-    return FromProperties(R.properties, T, options);
+function FromMappedResult(R, T) {
+    return FromProperties(R.properties, T);
 }
 // prettier-ignore
-export function ExtractFromMappedResult(R, T, options) {
-    const P = FromMappedResult(R, T, options);
+export function ExtractFromMappedResult(R, T) {
+    const P = FromMappedResult(R, T);
     return MappedResult(P);
 }

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

@@ -0,0 +1,5 @@
+import type { TSchema } from '../schema/index.mjs';
+import { type TExtract } from './extract.mjs';
+import { type TTemplateLiteral, type TTemplateLiteralToUnion } from '../template-literal/index.mjs';
+export type TExtractFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (TExtract<TTemplateLiteralToUnion<L>, R>);
+export declare function ExtractFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema>(L: L, R: R): TExtractFromTemplateLiteral<L, R>;

package/build/import/type/extract/extract-from-template-literal.mjs

@@ -0,0 +1,5 @@
+import { Extract } from './extract.mjs';
+import { TemplateLiteralToUnion } from '../template-literal/index.mjs';
+export function ExtractFromTemplateLiteral(L, R) {
+    return Extract(TemplateLiteralToUnion(L), R);
+}

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

@@ -1,21 +1,21 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Assert, AssertRest, AssertType, UnionToTuple } from '../helpers/index.mjs';
+import type { AssertRest, AssertType, UnionToTuple } from '../helpers/index.mjs';
 import type { TMappedResult } from '../mapped/index.mjs';
-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 TTemplateLiteral } from '../template-literal/index.mjs';
 import { type TExtractFromMappedResult } from './extract-from-mapped-result.mjs';
-type TExtractTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{
-    [K in T]: TLiteral<K>;
-}[T]>>>;
-type TExtractTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = Extract<Static<L>, Static<R>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never;
+import { type TExtractFromTemplateLiteral } from './extract-from-template-literal.mjs';
 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;
-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);
+export type TExtract<L extends TSchema, U extends TSchema> = (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 TTemplateLiteral, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromTemplateLiteral<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>(L: L, R: R, options?: SchemaOptions): TExtract<L, R>;
+export declare function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
 export {};

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

@@ -1,9 +1,9 @@
-import { TemplateLiteralToUnion } from '../template-literal/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Never } from '../never/index.mjs';
 import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { ExtractFromMappedResult } from './extract-from-mapped-result.mjs';
+import { ExtractFromTemplateLiteral } from './extract-from-template-literal.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -14,10 +14,12 @@ function ExtractRest(L, R) {
 }
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
 export function Extract(L, R, options = {}) {
+    // overloads
+    if (IsTemplateLiteral(L))
+        return CloneType(ExtractFromTemplateLiteral(L, R), options);
+    if (IsMappedResult(L))
+        return CloneType(ExtractFromMappedResult(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);
+    return CloneType(IsUnion(L) ? ExtractRest(L.anyOf, R) :
+        ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
 }

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

@@ -1,2 +1,3 @@
 export * from './extract-from-mapped-result.mjs';
+export * from './extract-from-template-literal.mjs';
 export * from './extract.mjs';

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

@@ -1,2 +1,3 @@
 export * from './extract-from-mapped-result.mjs';
+export * from './extract-from-template-literal.mjs';
 export * from './extract.mjs';

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

@@ -9,13 +9,11 @@ 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 TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, PartialResolve<L>]> : Acc);
+type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TPartial<L>]> : Acc);
 type TFromProperties<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]>;
 }>;
-type PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
-declare function PartialResolve<T extends TSchema>(T: T): PartialResolve<T>;
-export type TPartial<T extends TSchema> = PartialResolve<T>;
+export type TPartial<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<TPartial<S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
 /** `[Json]` Constructs a type where all properties are optional */
 export declare function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>;
 /** `[Json]` Constructs a type where all properties are optional */

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

@@ -20,6 +20,9 @@ function FromProperties(T) {
         return { ...Acc, [K]: Optional(T[K]) };
     }, {});
 }
+// ------------------------------------------------------------------
+// PartialResolve
+// ------------------------------------------------------------------
 // prettier-ignore
 function PartialResolve(T) {
     return (IsIntersect(T) ? Intersect(FromRest(T.allOf)) :

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

@@ -9,12 +9,11 @@ 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 TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TRequiredResolve<L>]> : Acc);
+type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TRequired<L>]> : Acc);
 type TFromProperties<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];
 }>;
-type TRequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<TRequiredResolve<S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
-export type TRequired<T extends TSchema> = TRequiredResolve<T>;
+export type TRequired<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<TRequired<S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
 /** `[Json]` Constructs a type where all properties are required */
 export declare function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
 /** `[Json]` Constructs a type where all properties are required */

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

@@ -19,6 +19,9 @@ function FromProperties(T) {
         return { ...Acc, [K]: Discard(T[K], [OptionalKind]) };
     }, {});
 }
+// ------------------------------------------------------------------
+// RequiredResolve
+// ------------------------------------------------------------------
 // prettier-ignore
 function RequiredResolve(T) {
     return (IsIntersect(T) ? Intersect(FromRest(T.allOf)) :

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

@@ -1,7 +1,9 @@
+import type { Static } from '../static/index.mjs';
 import type { TTemplateLiteral } from './template-literal.mjs';
-import { type TUnion } from '../union/index.mjs';
+import type { UnionToTuple } from '../helpers/index.mjs';
+import { type TUnionEvaluated } from '../union/index.mjs';
 import { type TLiteral } from '../literal/index.mjs';
-import { type TString } from '../string/index.mjs';
-import { type TNever } from '../never/index.mjs';
+export type TTemplateLiteralToUnionLiteralArray<T extends string[], Acc extends TLiteral[] = []> = (T extends [infer L extends string, ...infer R extends string[]] ? TTemplateLiteralToUnionLiteralArray<R, [...Acc, TLiteral<L>]> : Acc);
+export type TTemplateLiteralToUnion<T extends TTemplateLiteral, U extends string[] = UnionToTuple<Static<T>>> = TUnionEvaluated<TTemplateLiteralToUnionLiteralArray<U>>;
 /** Returns a Union from the given TemplateLiteral */
-export declare function TemplateLiteralToUnion(schema: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;
+export declare function TemplateLiteralToUnion<T extends TTemplateLiteral>(schema: TTemplateLiteral): TTemplateLiteralToUnion<T>;

package/build/import/type/template-literal/union.mjs

@@ -1,12 +1,9 @@
-import { Union } from '../union/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
 import { Literal } from '../literal/index.mjs';
 import { TemplateLiteralGenerate } from './generate.mjs';
-// ------------------------------------------------------------------
-// TemplateLiteralToUnion
-// ------------------------------------------------------------------
 /** Returns a Union from the given TemplateLiteral */
 export function TemplateLiteralToUnion(schema) {
     const R = TemplateLiteralGenerate(schema);
     const L = R.map((S) => Literal(S));
-    return Union(L);
+    return UnionEvaluated(L);
 }

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

@@ -5,9 +5,9 @@ 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, type TExcludeFromMappedResult } from '../exclude/index.mjs';
+import { type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } 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 { type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from '../extract/index.mjs';
 import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from '../indexed/index.mjs';
 import { type IntegerOptions, type TInteger } from '../integer/index.mjs';
 import { Intersect, type IntersectOptions } from '../intersect/index.mjs';
@@ -81,6 +81,8 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
     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 */
+    Exclude<L extends TTemplateLiteral, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromTemplateLiteral<L, R>;
+    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
     Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
     /** `[Json]` Creates a Conditional type */
     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>;
@@ -91,6 +93,8 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     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 */
+    Extract<L extends TTemplateLiteral, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromTemplateLiteral<L, R>;
+    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
     /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>;

package/build/require/index.d.ts

@@ -19,9 +19,9 @@ export { ConstructorParameters, type TConstructorParameters } from './type/const
 export { Date, type TDate, type DateOptions } from './type/date/index';
 export { Deref, type TDeref } from './type/deref/index';
 export { Enum, type TEnum } from './type/enum/index';
-export { Exclude, type TExclude, type TExcludeFromMappedResult } from './type/exclude/index';
+export { Exclude, type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from './type/exclude/index';
 export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey } from './type/extends/index';
-export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index';
+export { Extract, type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from './type/extract/index';
 export { Function, type TFunction } from './type/function/index';
 export { Index, IndexPropertyKeys, IndexFromPropertyKeys, IndexFromPropertyKey, IndexFromMappedKey, IndexFromMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexFromPropertyKeys, type TIndexFromPropertyKey, type TIndexFromMappedKey, type TIndexFromMappedResult, } from './type/indexed/index';
 export { InstanceType, type TInstanceType } from './type/instance-type/index';
@@ -57,7 +57,7 @@ export { type Static, type StaticDecode, type StaticEncode, type TDecodeType, ty
 export { Strict } from './type/strict/index';
 export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index';
 export { Symbol, type TSymbol, type TSymbolValue } from './type/symbol/index';
-export { TemplateLiteral, TemplateLiteralSyntax, TemplateLiteralGenerate, TemplateLiteralParse, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralExpressionGenerate, IsTemplateLiteralExpressionFinite, type TTemplateLiteral, type TTemplateLiteralSyntax, type TTemplateLiteralGenerate, type TTemplateLiteralKind, type TIsTemplateLiteralFinite, } from './type/template-literal/index';
+export { TemplateLiteral, TemplateLiteralSyntax, TemplateLiteralGenerate, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralToUnion, IsTemplateLiteralFinite, TemplateLiteralExpressionGenerate, IsTemplateLiteralExpressionFinite, type TTemplateLiteral, type TTemplateLiteralSyntax, type TTemplateLiteralGenerate, type TTemplateLiteralKind, type TTemplateLiteralToUnion, type TIsTemplateLiteralFinite, } from './type/template-literal/index';
 export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } from './type/transform/index';
 export { Tuple, type TTuple } from './type/tuple/index';
 export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index';

package/build/require/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexFromPropertyKeys = exports.IndexPropertyKeys = exports.Index = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = exports.Increment = exports.SetUnionMany = exports.SetUnion = exports.SetIsSubset = exports.SetIntersectMany = exports.SetIntersect = exports.SetIncludes = exports.SetDistinct = exports.SetComplement = exports.TypeBoxError = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
 exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.ReadonlyFromMappedResult = exports.Readonly = exports.Promise = exports.Pick = exports.PartialFromMappedResult = exports.Partial = exports.Parameters = exports.OptionalFromMappedResult = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.MappedFunctionReturnType = exports.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfFromMappedResult = exports.KeyOfPropertyKeysToRest = exports.KeyOfPropertyKeys = exports.KeyOf = exports.Uppercase = exports.Uncapitalize = exports.Lowercase = exports.Capitalize = exports.IntrinsicFromMappedKey = exports.Intrinsic = exports.Iterator = exports.IntersectEvaluated = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexFromMappedResult = exports.IndexFromMappedKey = exports.IndexFromPropertyKey = void 0;
-exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = exports.Unsafe = exports.Unknown = exports.UnionEvaluated = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.IsTemplateLiteralExpressionFinite = exports.TemplateLiteralExpressionGenerate = exports.IsTemplateLiteralFinite = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.TemplateLiteralGenerate = exports.TemplateLiteralSyntax = exports.TemplateLiteral = void 0;
+exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = exports.Unsafe = exports.Unknown = exports.UnionEvaluated = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.IsTemplateLiteralExpressionFinite = exports.TemplateLiteralExpressionGenerate = exports.IsTemplateLiteralFinite = exports.TemplateLiteralToUnion = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.TemplateLiteralGenerate = exports.TemplateLiteralSyntax = exports.TemplateLiteral = void 0;
 // ------------------------------------------------------------------
 // Infrastructure
 // ------------------------------------------------------------------
@@ -182,6 +182,7 @@ Object.defineProperty(exports, "TemplateLiteralSyntax", { enumerable: true, get:
 Object.defineProperty(exports, "TemplateLiteralGenerate", { enumerable: true, get: function () { return index_57.TemplateLiteralGenerate; } });
 Object.defineProperty(exports, "TemplateLiteralParse", { enumerable: true, get: function () { return index_57.TemplateLiteralParse; } });
 Object.defineProperty(exports, "TemplateLiteralParseExact", { enumerable: true, get: function () { return index_57.TemplateLiteralParseExact; } });
+Object.defineProperty(exports, "TemplateLiteralToUnion", { enumerable: true, get: function () { return index_57.TemplateLiteralToUnion; } });
 Object.defineProperty(exports, "IsTemplateLiteralFinite", { enumerable: true, get: function () { return index_57.IsTemplateLiteralFinite; } });
 Object.defineProperty(exports, "TemplateLiteralExpressionGenerate", { enumerable: true, get: function () { return index_57.TemplateLiteralExpressionGenerate; } });
 Object.defineProperty(exports, "IsTemplateLiteralExpressionFinite", { enumerable: true, get: function () { return index_57.IsTemplateLiteralExpressionFinite; } });

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

@@ -1,4 +1,4 @@
-import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TSchema } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TExclude } from './exclude';
@@ -7,5 +7,5 @@ type TFromProperties<K extends TProperties, T extends TSchema> = ({
 });
 type TFromMappedResult<R extends TMappedResult, T extends TSchema> = (TFromProperties<R['properties'], T>);
 export type TExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>> = (TMappedResult<P>);
-export declare function ExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T, options: SchemaOptions): TMappedResult<P>;
+export declare function ExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T): TMappedResult<P>;
 export {};

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

@@ -5,18 +5,18 @@ exports.ExcludeFromMappedResult = void 0;
 const index_1 = require("../mapped/index");
 const exclude_1 = require("./exclude");
 // prettier-ignore
-function FromProperties(P, U, options) {
+function FromProperties(P, U) {
     return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, exclude_1.Exclude)(P[K2], U, options) };
+        return { ...Acc, [K2]: (0, exclude_1.Exclude)(P[K2], U) };
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(R, T, options) {
-    return FromProperties(R.properties, T, options);
+function FromMappedResult(R, T) {
+    return FromProperties(R.properties, T);
 }
 // prettier-ignore
-function ExcludeFromMappedResult(R, T, options) {
-    const P = FromMappedResult(R, T, options);
+function ExcludeFromMappedResult(R, T) {
+    const P = FromMappedResult(R, T);
     return (0, index_1.MappedResult)(P);
 }
 exports.ExcludeFromMappedResult = ExcludeFromMappedResult;

package/build/require/type/exclude/exclude-from-template-literal.d.ts

@@ -0,0 +1,5 @@
+import type { TSchema } from '../schema/index';
+import { TExclude } from './exclude';
+import { type TTemplateLiteral, type TTemplateLiteralToUnion } from '../template-literal/index';
+export type TExcludeFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (TExclude<TTemplateLiteralToUnion<L>, R>);
+export declare function ExcludeFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema>(L: L, R: R): TExcludeFromTemplateLiteral<L, R>;

package/build/require/type/exclude/exclude-from-template-literal.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExcludeFromTemplateLiteral = void 0;
+const exclude_1 = require("./exclude");
+const index_1 = require("../template-literal/index");
+function ExcludeFromTemplateLiteral(L, R) {
+    return (0, exclude_1.Exclude)((0, index_1.TemplateLiteralToUnion)(L), R);
+}
+exports.ExcludeFromTemplateLiteral = ExcludeFromTemplateLiteral;

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

@@ -1,21 +1,21 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
-import type { UnionToTuple, AssertRest, AssertType, Assert } from '../helpers/index';
+import type { UnionToTuple, AssertRest, AssertType } from '../helpers/index';
 import type { TMappedResult } from '../mapped/index';
 import { type TTemplateLiteral } from '../template-literal/index';
 import { type TUnion } from '../union/index';
 import { type TNever } from '../never/index';
-import { type TLiteral } from '../literal/index';
 import { type Static } from '../static/index';
 import { type TUnionEvaluated } from '../union/index';
 import { type TExcludeFromMappedResult } from './exclude-from-mapped-result';
-type TExcludeTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{
-    [K in T]: TLiteral<K>;
-}[T]>>>;
-type TExcludeTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (Exclude<Static<L>, Static<R>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never);
+import { type TExcludeFromTemplateLiteral } from './exclude-from-template-literal';
 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;
-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);
+export type TExclude<L extends TSchema, R extends TSchema> = (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 TSchema, R extends TSchema>(L: L, R: R, options?: SchemaOptions): TExclude<L, R>;
+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 TTemplateLiteral, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromTemplateLiteral<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 {};

package/build/require/type/exclude/exclude.js

@@ -2,27 +2,29 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Exclude = void 0;
-const index_1 = require("../template-literal/index");
-const index_2 = require("../union/index");
-const index_3 = require("../never/index");
-const index_4 = require("../extends/index");
+const index_1 = require("../union/index");
+const index_2 = require("../never/index");
+const index_3 = require("../extends/index");
 const type_1 = require("../clone/type");
 const exclude_from_mapped_result_1 = require("./exclude-from-mapped-result");
+const exclude_from_template_literal_1 = require("./exclude-from-template-literal");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 const type_2 = require("../guard/type");
 function ExcludeRest(L, R) {
-    const excluded = L.filter((inner) => (0, index_4.ExtendsCheck)(inner, R) === index_4.ExtendsResult.False);
-    return excluded.length === 1 ? excluded[0] : (0, index_2.Union)(excluded);
+    const excluded = L.filter((inner) => (0, index_3.ExtendsCheck)(inner, R) === index_3.ExtendsResult.False);
+    return excluded.length === 1 ? excluded[0] : (0, index_1.Union)(excluded);
 }
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
 function Exclude(L, R, options = {}) {
+    // overloads
+    if ((0, type_2.IsTemplateLiteral)(L))
+        return (0, type_1.CloneType)((0, exclude_from_template_literal_1.ExcludeFromTemplateLiteral)(L, R), options);
+    if ((0, type_2.IsMappedResult)(L))
+        return (0, type_1.CloneType)((0, exclude_from_mapped_result_1.ExcludeFromMappedResult)(L, R), options);
     // prettier-ignore
-    return (0, type_1.CloneType)(((0, type_2.IsMappedResult)(L) ? (0, exclude_from_mapped_result_1.ExcludeFromMappedResult)(L, R, options) :
-        (0, type_2.IsTemplateLiteral)(L) ? Exclude((0, index_1.TemplateLiteralToUnion)(L), R) :
-            (0, type_2.IsTemplateLiteral)(R) ? Exclude(L, (0, index_1.TemplateLiteralToUnion)(R)) :
-                (0, type_2.IsUnion)(L) ? ExcludeRest(L.anyOf, R) :
-                    (0, index_4.ExtendsCheck)(L, R) !== index_4.ExtendsResult.False ? (0, index_3.Never)() : L), options);
+    return (0, type_1.CloneType)((0, type_2.IsUnion)(L) ? ExcludeRest(L.anyOf, R) :
+        (0, index_3.ExtendsCheck)(L, R) !== index_3.ExtendsResult.False ? (0, index_2.Never)() : L, options);
 }
 exports.Exclude = Exclude;

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

@@ -1,2 +1,3 @@
 export * from './exclude-from-mapped-result';
+export * from './exclude-from-template-literal';
 export * from './exclude';

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

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./exclude-from-mapped-result"), exports);
+__exportStar(require("./exclude-from-template-literal"), exports);
 __exportStar(require("./exclude"), exports);

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

@@ -1,4 +1,4 @@
-import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TSchema } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TExtract } from './extract';
@@ -7,5 +7,5 @@ type TFromProperties<P extends TProperties, T extends TSchema> = ({
 });
 type TFromMappedResult<R extends TMappedResult, T extends TSchema> = (TFromProperties<R['properties'], T>);
 export type TExtractFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>> = (TMappedResult<P>);
-export declare function ExtractFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T, options: SchemaOptions): TMappedResult<P>;
+export declare function ExtractFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T): TMappedResult<P>;
 export {};

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

@@ -5,18 +5,18 @@ exports.ExtractFromMappedResult = void 0;
 const index_1 = require("../mapped/index");
 const extract_1 = require("./extract");
 // prettier-ignore
-function FromProperties(P, T, options) {
+function FromProperties(P, T) {
     return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, extract_1.Extract)(P[K2], T, options) };
+        return { ...Acc, [K2]: (0, extract_1.Extract)(P[K2], T) };
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(R, T, options) {
-    return FromProperties(R.properties, T, options);
+function FromMappedResult(R, T) {
+    return FromProperties(R.properties, T);
 }
 // prettier-ignore
-function ExtractFromMappedResult(R, T, options) {
-    const P = FromMappedResult(R, T, options);
+function ExtractFromMappedResult(R, T) {
+    const P = FromMappedResult(R, T);
     return (0, index_1.MappedResult)(P);
 }
 exports.ExtractFromMappedResult = ExtractFromMappedResult;

package/build/require/type/extract/extract-from-template-literal.d.ts

@@ -0,0 +1,5 @@
+import type { TSchema } from '../schema/index';
+import { type TExtract } from './extract';
+import { type TTemplateLiteral, type TTemplateLiteralToUnion } from '../template-literal/index';
+export type TExtractFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (TExtract<TTemplateLiteralToUnion<L>, R>);
+export declare function ExtractFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema>(L: L, R: R): TExtractFromTemplateLiteral<L, R>;

package/build/require/type/extract/extract-from-template-literal.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractFromTemplateLiteral = void 0;
+const extract_1 = require("./extract");
+const index_1 = require("../template-literal/index");
+function ExtractFromTemplateLiteral(L, R) {
+    return (0, extract_1.Extract)((0, index_1.TemplateLiteralToUnion)(L), R);
+}
+exports.ExtractFromTemplateLiteral = ExtractFromTemplateLiteral;

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

@@ -1,21 +1,21 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
-import type { Assert, AssertRest, AssertType, UnionToTuple } from '../helpers/index';
+import type { AssertRest, AssertType, UnionToTuple } from '../helpers/index';
 import type { TMappedResult } from '../mapped/index';
-import { type TTemplateLiteral } from '../template-literal/index';
-import { type TLiteral } from '../literal/index';
 import { type TUnion } from '../union/index';
 import { type Static } from '../static/index';
 import { type TNever } from '../never/index';
 import { type TUnionEvaluated } from '../union/index';
+import { type TTemplateLiteral } from '../template-literal/index';
 import { type TExtractFromMappedResult } from './extract-from-mapped-result';
-type TExtractTemplateLiteralResult<T extends string> = TUnionEvaluated<AssertRest<UnionToTuple<{
-    [K in T]: TLiteral<K>;
-}[T]>>>;
-type TExtractTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = Extract<Static<L>, Static<R>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never;
+import { type TExtractFromTemplateLiteral } from './extract-from-template-literal';
 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;
-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);
+export type TExtract<L extends TSchema, U extends TSchema> = (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 TTemplateLiteral, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromTemplateLiteral<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>(L: L, R: R, options?: SchemaOptions): TExtract<L, R>;
+export declare function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
 export {};

package/build/require/type/extract/extract.js

@@ -2,27 +2,29 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Extract = void 0;
-const index_1 = require("../template-literal/index");
-const index_2 = require("../union/index");
-const index_3 = require("../never/index");
-const index_4 = require("../extends/index");
+const index_1 = require("../union/index");
+const index_2 = require("../never/index");
+const index_3 = require("../extends/index");
 const type_1 = require("../clone/type");
 const extract_from_mapped_result_1 = require("./extract-from-mapped-result");
+const extract_from_template_literal_1 = require("./extract-from-template-literal");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 const type_2 = require("../guard/type");
 function ExtractRest(L, R) {
-    const extracted = L.filter((inner) => (0, index_4.ExtendsCheck)(inner, R) !== index_4.ExtendsResult.False);
-    return extracted.length === 1 ? extracted[0] : (0, index_2.Union)(extracted);
+    const extracted = L.filter((inner) => (0, index_3.ExtendsCheck)(inner, R) !== index_3.ExtendsResult.False);
+    return extracted.length === 1 ? extracted[0] : (0, index_1.Union)(extracted);
 }
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
 function Extract(L, R, options = {}) {
+    // overloads
+    if ((0, type_2.IsTemplateLiteral)(L))
+        return (0, type_1.CloneType)((0, extract_from_template_literal_1.ExtractFromTemplateLiteral)(L, R), options);
+    if ((0, type_2.IsMappedResult)(L))
+        return (0, type_1.CloneType)((0, extract_from_mapped_result_1.ExtractFromMappedResult)(L, R), options);
     // prettier-ignore
-    return (0, type_1.CloneType)(((0, type_2.IsMappedResult)(L) ? (0, extract_from_mapped_result_1.ExtractFromMappedResult)(L, R, options) :
-        (0, type_2.IsTemplateLiteral)(L) ? Extract((0, index_1.TemplateLiteralToUnion)(L), R) :
-            (0, type_2.IsTemplateLiteral)(R) ? Extract(L, (0, index_1.TemplateLiteralToUnion)(R)) :
-                (0, type_2.IsUnion)(L) ? ExtractRest(L.anyOf, R) :
-                    (0, index_4.ExtendsCheck)(L, R) !== index_4.ExtendsResult.False ? L : (0, index_3.Never)()), options);
+    return (0, type_1.CloneType)((0, type_2.IsUnion)(L) ? ExtractRest(L.anyOf, R) :
+        (0, index_3.ExtendsCheck)(L, R) !== index_3.ExtendsResult.False ? L : (0, index_2.Never)(), options);
 }
 exports.Extract = Extract;

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

@@ -1,2 +1,3 @@
 export * from './extract-from-mapped-result';
+export * from './extract-from-template-literal';
 export * from './extract';

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

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./extract-from-mapped-result"), exports);
+__exportStar(require("./extract-from-template-literal"), exports);
 __exportStar(require("./extract"), exports);

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

@@ -9,13 +9,11 @@ import { type TObject, type TProperties } from '../object/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TPartialFromMappedResult } from './partial-from-mapped-result';
-type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, PartialResolve<L>]> : Acc);
+type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TPartial<L>]> : Acc);
 type TFromProperties<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]>;
 }>;
-type PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
-declare function PartialResolve<T extends TSchema>(T: T): PartialResolve<T>;
-export type TPartial<T extends TSchema> = PartialResolve<T>;
+export type TPartial<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<TPartial<S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
 /** `[Json]` Constructs a type where all properties are optional */
 export declare function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>;
 /** `[Json]` Constructs a type where all properties are optional */

package/build/require/type/partial/partial.js

@@ -24,6 +24,9 @@ function FromProperties(T) {
         return { ...Acc, [K]: (0, index_1.Optional)(T[K]) };
     }, {});
 }
+// ------------------------------------------------------------------
+// PartialResolve
+// ------------------------------------------------------------------
 // prettier-ignore
 function PartialResolve(T) {
     return ((0, type_2.IsIntersect)(T) ? (0, index_3.Intersect)(FromRest(T.allOf)) :

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

@@ -9,12 +9,11 @@ import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TObject, type TProperties } from '../object/index';
 import { type TRequiredFromMappedResult } from './required-from-mapped-result';
-type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TRequiredResolve<L>]> : Acc);
+type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TRequired<L>]> : Acc);
 type TFromProperties<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];
 }>;
-type TRequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<TRequiredResolve<S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
-export type TRequired<T extends TSchema> = TRequiredResolve<T>;
+export type TRequired<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<TRequired<S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
 /** `[Json]` Constructs a type where all properties are required */
 export declare function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
 /** `[Json]` Constructs a type where all properties are required */

package/build/require/type/required/required.js

@@ -23,6 +23,9 @@ function FromProperties(T) {
         return { ...Acc, [K]: (0, index_5.Discard)(T[K], [index_4.OptionalKind]) };
     }, {});
 }
+// ------------------------------------------------------------------
+// RequiredResolve
+// ------------------------------------------------------------------
 // prettier-ignore
 function RequiredResolve(T) {
     return ((0, type_2.IsIntersect)(T) ? (0, index_1.Intersect)(FromRest(T.allOf)) :

package/build/require/type/template-literal/union.d.ts

@@ -1,7 +1,9 @@
+import type { Static } from '../static/index';
 import type { TTemplateLiteral } from './template-literal';
-import { type TUnion } from '../union/index';
+import type { UnionToTuple } from '../helpers/index';
+import { type TUnionEvaluated } from '../union/index';
 import { type TLiteral } from '../literal/index';
-import { type TString } from '../string/index';
-import { type TNever } from '../never/index';
+export type TTemplateLiteralToUnionLiteralArray<T extends string[], Acc extends TLiteral[] = []> = (T extends [infer L extends string, ...infer R extends string[]] ? TTemplateLiteralToUnionLiteralArray<R, [...Acc, TLiteral<L>]> : Acc);
+export type TTemplateLiteralToUnion<T extends TTemplateLiteral, U extends string[] = UnionToTuple<Static<T>>> = TUnionEvaluated<TTemplateLiteralToUnionLiteralArray<U>>;
 /** Returns a Union from the given TemplateLiteral */
-export declare function TemplateLiteralToUnion(schema: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;
+export declare function TemplateLiteralToUnion<T extends TTemplateLiteral>(schema: TTemplateLiteral): TTemplateLiteralToUnion<T>;

package/build/require/type/template-literal/union.js

@@ -5,13 +5,10 @@ exports.TemplateLiteralToUnion = void 0;
 const index_1 = require("../union/index");
 const index_2 = require("../literal/index");
 const generate_1 = require("./generate");
-// ------------------------------------------------------------------
-// TemplateLiteralToUnion
-// ------------------------------------------------------------------
 /** Returns a Union from the given TemplateLiteral */
 function TemplateLiteralToUnion(schema) {
     const R = (0, generate_1.TemplateLiteralGenerate)(schema);
     const L = R.map((S) => (0, index_2.Literal)(S));
-    return (0, index_1.Union)(L);
+    return (0, index_1.UnionEvaluated)(L);
 }
 exports.TemplateLiteralToUnion = TemplateLiteralToUnion;

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

@@ -5,9 +5,9 @@ import { type TComposite } from '../composite/index';
 import { type TConst } from '../const/index';
 import { type TDeref } from '../deref/index';
 import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index';
-import { type TExclude, type TExcludeFromMappedResult } from '../exclude/index';
+import { type TExclude, type TExcludeFromMappedResult, type TExcludeFromTemplateLiteral } from '../exclude/index';
 import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResult } from '../extends/index';
-import { type TExtract, type TExtractFromMappedResult } from '../extract/index';
+import { type TExtract, type TExtractFromMappedResult, type TExtractFromTemplateLiteral } from '../extract/index';
 import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from '../indexed/index';
 import { type IntegerOptions, type TInteger } from '../integer/index';
 import { Intersect, type IntersectOptions } from '../intersect/index';
@@ -81,6 +81,8 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
     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 */
+    Exclude<L extends TTemplateLiteral, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromTemplateLiteral<L, R>;
+    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
     Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
     /** `[Json]` Creates a Conditional type */
     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>;
@@ -91,6 +93,8 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     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 */
+    Extract<L extends TTemplateLiteral, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromTemplateLiteral<L, R>;
+    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
     /** `[Json]` Returns an Indexed property type for the given keys */
     Index<T extends TSchema, K extends TMappedResult>(T: T, K: K, options?: SchemaOptions): TIndexFromMappedResult<T, K>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.9",
+  "version": "0.32.11",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",