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

package/build/require/type/intersect/intersect.js

@@ -1,30 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Intersect = exports.IntersectResolve = void 0;
-const index_1 = require("../never/index");
-const index_2 = require("../modifiers/index");
-const index_3 = require("../symbols/index");
+exports.Intersect = void 0;
 const type_1 = require("../clone/type");
+const index_1 = require("../never/index");
+const intersect_create_1 = require("./intersect-create");
 const type_2 = require("../guard/type");
-function IntersectResolve(T) {
-    return (T.length === 0
-        ? (0, index_1.Never)()
-        : T.length === 1
-            ? T[0]
-            : (0, index_2.OptionalFromIntersect)(T));
-}
-exports.IntersectResolve = IntersectResolve;
 function Intersect(T, options = {}) {
     if (T.length === 0)
-        return (0, index_1.Never)();
+        return (0, index_1.Never)(options);
     if (T.length === 1)
         return (0, type_1.CloneType)(T[0], options);
     if (T.some((schema) => (0, type_2.TTransform)(schema)))
         throw new Error('Cannot intersect transform types');
-    const allObjects = T.every((schema) => (0, type_2.TObject)(schema));
-    const clonedUnevaluatedProperties = (0, type_2.TSchema)(options.unevaluatedProperties) ? { unevaluatedProperties: (0, type_1.CloneType)(options.unevaluatedProperties) } : {};
-    return (options.unevaluatedProperties === false || (0, type_2.TSchema)(options.unevaluatedProperties) || allObjects
-        ? { ...options, ...clonedUnevaluatedProperties, [index_3.Kind]: 'Intersect', type: 'object', allOf: (0, type_1.CloneRest)(T) }
-        : { ...options, ...clonedUnevaluatedProperties, [index_3.Kind]: 'Intersect', allOf: (0, type_1.CloneRest)(T) });
+    return (0, intersect_create_1.IntersectCreate)(T, options);
 }
 exports.Intersect = Intersect;

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

@@ -5,11 +5,11 @@ import { type TLiteral, TLiteralValue } from '../literal/index';
 import { type TNumber } from '../number/index';
 import { type SchemaOptions } from '../schema/index';
 import { KeyOfPropertyKeys } from './keyof-property-keys';
-import { UnionResolve } from '../union/index';
+import { UnionEvaluated } from '../union/index';
 import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result';
 type FromLiterals<T extends TLiteralValue[]> = (T extends [infer L extends TLiteralValue, ...infer R extends TLiteralValue[]] ? L extends '[number]' ? [TNumber, ...FromLiterals<R>] : [TLiteral<L>, ...FromLiterals<R>] : []);
 declare function FromLiterals<T extends TLiteralValue[]>(T: [...T]): FromLiterals<T>;
-export type TKeyOf<T extends TSchema> = (Ensure<UnionResolve<FromLiterals<KeyOfPropertyKeys<T>>>>);
+export type TKeyOf<T extends TSchema> = (Ensure<UnionEvaluated<FromLiterals<KeyOfPropertyKeys<T>>>>);
 export declare function KeyOf<T extends TMappedResult>(T: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
 export declare function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>;
 export {};

package/build/require/type/keyof/keyof.js

@@ -21,7 +21,7 @@ function KeyOf(T, options = {}) {
         return (0, keyof_from_mapped_result_1.KeyOfFromMappedResult)(T, options);
     }
     else {
-        const K = (0, index_3.UnionResolve)(FromLiterals((0, keyof_property_keys_1.KeyOfPropertyKeys)(T)));
+        const K = (0, index_3.UnionEvaluated)(FromLiterals((0, keyof_property_keys_1.KeyOfPropertyKeys)(T)));
         return (0, type_1.CloneType)(K, options);
     }
 }

package/build/require/type/mapped/mapped.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mapped = void 0;
-const type_1 = require("../guard/type");
 const index_1 = require("../symbols/index");
-const type_2 = require("../clone/type");
+const type_1 = require("../clone/type");
 const index_2 = require("../discard/index");
 const index_3 = require("../array/index");
 const index_4 = require("../async-iterator/index");
@@ -20,7 +19,7 @@ const index_14 = require("../readonly/index");
 const index_15 = require("../tuple/index");
 const index_16 = require("../union/index");
 const mapped_result_1 = require("./mapped-result");
-const type_3 = require("../guard/type");
+const type_2 = require("../guard/type");
 function FromMappedResult(K, P) {
     return (K in P
         ? FromSchemaType(K, P[K])
@@ -48,20 +47,20 @@ function FromProperties(K, T) {
     }, {});
 }
 function FromSchemaType(K, T) {
-    return ((0, type_3.TOptional)(T) ? (0, index_12.Optional)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.OptionalKind]))) :
-        (0, type_3.TReadonly)(T) ? (0, index_14.Readonly)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.ReadonlyKind]))) :
-            (0, type_3.TMappedResult)(T) ? FromMappedResult(K, T.properties) :
-                (0, type_3.TMappedKey)(T) ? FromMappedKey(K, T.keys) :
-                    (0, type_3.TConstructor)(T) ? (0, index_5.Constructor)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
-                        (0, type_3.TFunction)(T) ? (0, index_6.Function)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
-                            (0, type_3.TAsyncIterator)(T) ? (0, index_4.AsyncIterator)(FromSchemaType(K, T.items)) :
-                                (0, type_3.TIterator)(T) ? (0, index_9.Iterator)(FromSchemaType(K, T.items)) :
-                                    (0, type_3.TIntersect)(T) ? (0, index_8.Intersect)(FromRest(K, T.allOf)) :
-                                        (0, type_3.TUnion)(T) ? (0, index_16.Union)(FromRest(K, T.anyOf)) :
-                                            (0, type_3.TTuple)(T) ? (0, index_15.Tuple)(FromRest(K, T.items ?? [])) :
-                                                (0, type_3.TObject)(T) ? (0, index_11.Object)(FromProperties(K, T.properties)) :
-                                                    (0, type_3.TArray)(T) ? (0, index_3.Array)(FromSchemaType(K, T.items)) :
-                                                        (0, type_3.TPromise)(T) ? (0, index_13.Promise)(FromSchemaType(K, T.item)) :
+    return ((0, type_2.TOptional)(T) ? (0, index_12.Optional)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.OptionalKind]))) :
+        (0, type_2.TReadonly)(T) ? (0, index_14.Readonly)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.ReadonlyKind]))) :
+            (0, type_2.TMappedResult)(T) ? FromMappedResult(K, T.properties) :
+                (0, type_2.TMappedKey)(T) ? FromMappedKey(K, T.keys) :
+                    (0, type_2.TConstructor)(T) ? (0, index_5.Constructor)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                        (0, type_2.TFunction)(T) ? (0, index_6.Function)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                            (0, type_2.TAsyncIterator)(T) ? (0, index_4.AsyncIterator)(FromSchemaType(K, T.items)) :
+                                (0, type_2.TIterator)(T) ? (0, index_9.Iterator)(FromSchemaType(K, T.items)) :
+                                    (0, type_2.TIntersect)(T) ? (0, index_8.Intersect)(FromRest(K, T.allOf)) :
+                                        (0, type_2.TUnion)(T) ? (0, index_16.Union)(FromRest(K, T.anyOf)) :
+                                            (0, type_2.TTuple)(T) ? (0, index_15.Tuple)(FromRest(K, T.items ?? [])) :
+                                                (0, type_2.TObject)(T) ? (0, index_11.Object)(FromProperties(K, T.properties)) :
+                                                    (0, type_2.TArray)(T) ? (0, index_3.Array)(FromSchemaType(K, T.items)) :
+                                                        (0, type_2.TPromise)(T) ? (0, index_13.Promise)(FromSchemaType(K, T.item)) :
                                                             T);
 }
 function FromMappedFunctionReturnType(K, T) {
@@ -71,9 +70,9 @@ function FromMappedFunctionReturnType(K, T) {
         : {});
 }
 function Mapped(key, map, options = {}) {
-    const K = (0, type_1.TSchema)(key) ? (0, index_7.IndexPropertyKeys)(key) : key;
+    const K = (0, type_2.TSchema)(key) ? (0, index_7.IndexPropertyKeys)(key) : key;
     const RT = map({ [index_1.Kind]: 'MappedKey', keys: K });
     const R = FromMappedFunctionReturnType(K, RT);
-    return (0, type_2.CloneType)((0, index_11.Object)(R), options);
+    return (0, type_1.CloneType)((0, index_11.Object)(R), options);
 }
 exports.Mapped = Mapped;

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

@@ -4,8 +4,6 @@ import type { Evaluate } from '../helpers/index';
 import type { TReadonly } from '../readonly/index';
 import type { TOptional } from '../optional/index';
 import { Kind } from '../symbols/index';
-export type TPropertyKey = string | number;
-export type TProperties = Record<TPropertyKey, TSchema>;
 type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
 }[keyof T];
@@ -16,10 +14,12 @@ type OptionalPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never;
 }[keyof T];
 type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
-type PropertiesResolve<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
-export type ObjectResolve<T extends TProperties, P extends unknown[]> = PropertiesResolve<T, {
+type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
+export type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
     [K in keyof T]: Static<T[K], P>;
 }>;
+export type TPropertyKey = string | number;
+export type TProperties = Record<TPropertyKey, TSchema>;
 export type TAdditionalProperties = undefined | TSchema | boolean;
 export interface ObjectOptions extends SchemaOptions {
     additionalProperties?: TAdditionalProperties;
@@ -28,7 +28,7 @@ export interface ObjectOptions extends SchemaOptions {
 }
 export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
     [Kind]: 'Object';
-    static: ObjectResolve<T, this['params']>;
+    static: ObjectStatic<T, this['params']>;
     additionalProperties?: TAdditionalProperties;
     type: 'object';
     properties: T;

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

@@ -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/require/type/record/record.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Record = exports.RecordResolve = void 0;
+exports.Record = void 0;
 const index_1 = require("../object/index");
 const index_2 = require("../never/index");
 const index_3 = require("../union/index");
@@ -49,7 +49,6 @@ function RecordResolve(K, T) {
                         (0, type_2.TNumber)(K) ? FromNumberKey(K, T) :
                             (0, index_2.Never)());
 }
-exports.RecordResolve = RecordResolve;
 function Record(K, T, options = {}) {
     return (0, type_1.CloneType)(RecordResolve(K, T), options);
 }

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

@@ -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/require/type/recursive/recursive.js

@@ -10,10 +10,6 @@ function Recursive(callback, options = {}) {
         options.$id = `T${Ordinal++}`;
     const thisType = callback({ [index_1.Kind]: 'This', $ref: `${options.$id}` });
     thisType.$id = options.$id;
-    return (0, type_1.CloneType)({
-        ...options,
-        [index_1.Hint]: 'Recursive',
-        ...thisType,
-    });
+    return (0, type_1.CloneType)({ ...options, [index_1.Hint]: 'Recursive', ...thisType });
 }
 exports.Recursive = Recursive;

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

@@ -1,19 +1,19 @@
-import type { Ensure, Assert, Trim } from '../helpers/index';
+import type { Assert, Trim } from '../helpers/index';
 import type { TTemplateLiteralKind, TTemplateLiteral } from './index';
 import { type TLiteral } from '../literal/index';
 import { type TBoolean } from '../boolean/index';
 import { type TBigInt } from '../bigint/index';
 import { type TNumber } from '../number/index';
 import { type TString } from '../string/index';
-import { UnionResolve } from '../union/index';
+import { UnionEvaluated } from '../union/index';
 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/require/type/template-literal/template-literal.d.ts

@@ -12,14 +12,14 @@ import type { Static } from '../static/index';
 import { TemplateLiteralSyntax } from './syntax';
 import { EmptyString } from '../helpers/index';
 import { Kind } from '../symbols/index';
-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/require/type/transform/transform.d.ts

@@ -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/require/type/transform/transform.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Transform = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = void 0;
-const type_1 = require("../guard/type");
-const type_2 = require("../clone/type");
+const type_1 = require("../clone/type");
 const index_1 = require("../symbols/index");
+const type_2 = require("../guard/type");
 class TransformDecodeBuilder {
     constructor(schema) {
         this.schema = schema;
@@ -29,8 +29,8 @@ class TransformEncodeBuilder {
         return { ...schema, [index_1.TransformKind]: Codec };
     }
     Encode(encode) {
-        const schema = (0, type_2.CloneType)(this.schema);
-        return ((0, type_1.TTransform)(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
+        const schema = (0, type_1.CloneType)(this.schema);
+        return ((0, type_2.TTransform)(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
     }
 }
 exports.TransformEncodeBuilder = TransformEncodeBuilder;

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

@@ -1,11 +1,11 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Static } from '../static/index';
 import { Kind } from '../symbols/index';
-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/require/type/type/json.d.ts

@@ -10,7 +10,7 @@ import { type TExtends, type TExtendsFromMappedKey, type TExtendsFromMappedResul
 import { type TExtract, type TExtractFromMappedResult } from '../extract/index';
 import { TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from '../indexed/index';
 import { type IntegerOptions, type TInteger } from '../integer/index';
-import { type IntersectOptions, type IntersectResolve } from '../intersect/index';
+import { Intersect, type IntersectOptions } from '../intersect/index';
 import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index';
 import { type TKeyOf, type TKeyOfFromMappedResult } from '../keyof/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
@@ -37,7 +37,7 @@ import { type TString, type StringOptions } from '../string/index';
 import { type TTemplateLiteral, type TTemplateLiteralKind, type TemplateLiteralSyntax } from '../template-literal/index';
 import { TransformDecodeBuilder } from '../transform/index';
 import { type TTuple } from '../tuple/index';
-import { type UnionResolve } from '../union/index';
+import { Union } from '../union/index';
 import { type TUnknown } from '../unknown/index';
 import { type TUnsafe, type UnsafeOptions } from '../unsafe/index';
 export declare class JsonTypeBuilder {
@@ -64,7 +64,7 @@ export declare class JsonTypeBuilder {
     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>;
@@ -97,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/require/type/union/index.d.ts

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

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

@@ -14,4 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./union-evaluated"), exports);
+__exportStar(require("./union-type"), exports);
 __exportStar(require("./union"), exports);

package/build/require/type/union/union-create.d.ts

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

package/build/require/type/union/union-create.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionCreate = void 0;
+const type_1 = require("../clone/type");
+const index_1 = require("../symbols/index");
+function UnionCreate(T, options) {
+    return { ...options, [index_1.Kind]: 'Union', anyOf: (0, type_1.CloneRest)(T) };
+}
+exports.UnionCreate = UnionCreate;

package/build/require/type/union/union-evaluated.d.ts

@@ -0,0 +1,16 @@
+import type { SchemaOptions, TSchema } from '../schema/index';
+import { type TNever } from '../never/index';
+import { type TOptional } from '../optional/index';
+import type { TReadonly } from '../readonly/index';
+import type { TUnion } from './union-type';
+type IsUnionOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? true : IsUnionOptional<R> : false);
+declare function IsUnionOptional<T extends TSchema[]>(T: T): IsUnionOptional<T>;
+type RemoveOptionalFromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? [RemoveOptionalFromType<S>, ...RemoveOptionalFromRest<R>] : [L, ...RemoveOptionalFromRest<R>] : []);
+declare function RemoveOptionalFromRest<T extends TSchema[]>(T: T): RemoveOptionalFromRest<T>;
+type RemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<RemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? RemoveOptionalFromType<S> : T);
+declare function RemoveOptionalFromType<T extends TSchema>(T: T): RemoveOptionalFromType<T>;
+type ResolveUnion<T extends TSchema[], R extends TSchema[] = RemoveOptionalFromRest<T>> = (IsUnionOptional<T> extends true ? TOptional<TUnion<R>> : TUnion<R>);
+declare function ResolveUnion<T extends TSchema[]>(T: T, options: SchemaOptions): ResolveUnion<T>;
+export type UnionEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : ResolveUnion<T>);
+export declare function UnionEvaluated<T extends TSchema[], R = UnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R;
+export {};

package/build/require/type/union/union-evaluated.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionEvaluated = void 0;
+const index_1 = require("../symbols/index");
+const type_1 = require("../clone/type");
+const index_2 = require("../discard/index");
+const index_3 = require("../never/index");
+const index_4 = require("../optional/index");
+const union_create_1 = require("./union-create");
+const type_2 = require("../guard/type");
+function IsUnionOptional(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? (0, type_2.TOptional)(L)
+            ? true
+            : IsUnionOptional(R)
+        : false);
+}
+function RemoveOptionalFromRest(T) {
+    return (T.map(T => RemoveOptionalFromType(T)));
+}
+function RemoveOptionalFromType(T) {
+    return ((0, index_2.Discard)(T, [index_1.OptionalKind]));
+}
+function ResolveUnion(T, options) {
+    return (IsUnionOptional(T)
+        ? (0, index_4.Optional)((0, union_create_1.UnionCreate)(RemoveOptionalFromRest(T), options))
+        : (0, union_create_1.UnionCreate)(RemoveOptionalFromRest(T), options));
+}
+function UnionEvaluated(T, options = {}) {
+    return (T.length === 0 ? (0, index_3.Never)(options) :
+        T.length === 1 ? (0, type_1.CloneType)(T[0], options) :
+            ResolveUnion(T, options));
+}
+exports.UnionEvaluated = UnionEvaluated;

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

@@ -0,0 +1,12 @@
+import type { TSchema } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+type UnionStatic<T extends TSchema[], P extends unknown[]> = {
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
+}[number];
+export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Union';
+    static: UnionStatic<T, this['params']>;
+    anyOf: T;
+}
+export {};

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../symbols/index");

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

@@ -1,15 +1,5 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
-import type { Static } from '../static/index';
 import { type TNever } from '../never/index';
-import { OptionalFromUnion } from '../modifiers/index';
-import { Kind } from '../symbols/index';
-export type UnionResolve<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : OptionalFromUnion<T>);
-export declare function UnionResolve<T extends TSchema[]>(T: [...T]): UnionResolve<T>;
-export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
-    [Kind]: 'Union';
-    static: {
-        [K in keyof T]: T[K] extends TSchema ? Static<T[K], this['params']> : never;
-    }[number];
-    anyOf: T;
-}
-export declare function Union<T extends TSchema[]>(T: [...T], options?: SchemaOptions): UnionResolve<T>;
+import type { TUnion } from './union-type';
+export type Union<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TUnion<T>);
+export declare function Union<T extends TSchema[]>(T: [...T], options?: SchemaOptions): Union<T>;

package/build/require/type/union/union.js

@@ -1,20 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Union = exports.UnionResolve = void 0;
+exports.Union = void 0;
 const index_1 = require("../never/index");
-const index_2 = require("../modifiers/index");
 const type_1 = require("../clone/type");
-const index_3 = require("../symbols/index");
-function UnionResolve(T) {
-    return (T.length === 0 ? (0, index_1.Never)() :
-        T.length === 1 ? T[0] :
-            (0, index_2.OptionalFromUnion)(T));
-}
-exports.UnionResolve = UnionResolve;
+const union_create_1 = require("./union-create");
 function Union(T, options = {}) {
     return (T.length === 0 ? (0, index_1.Never)(options) :
         T.length === 1 ? (0, type_1.CloneType)(T[0], options) :
-            { ...options, [index_3.Kind]: 'Union', anyOf: (0, type_1.CloneRest)(T)
-            });
+            (0, union_create_1.UnionCreate)(T, options));
 }
 exports.Union = Union;

package/build/require/value/delta/delta.d.ts

@@ -17,7 +17,7 @@ export declare const Delete: import("../../type/object/object").TObject<{
     path: import("../../type/string/string").TString;
 }>;
 export type Edit = Static<typeof Edit>;
-export declare const Edit: import("../../type/union/union").TUnion<[import("../../type/object/object").TObject<{
+export declare const Edit: import("../../type/union/union-type").TUnion<[import("../../type/object/object").TObject<{
     type: import("../../type/literal/literal").TLiteral<"insert">;
     path: import("../../type/string/string").TString;
     value: import("../../type/unknown/unknown").TUnknown;

package/package.json

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

package/readme.md

@@ -65,9 +65,9 @@ License MIT
 - [Types](#types)
   - [Json](#types-json)
   - [JavaScript](#types-javascript)
+  - [Modules](#types-modules)
   - [Options](#types-options)
   - [Properties](#types-properties)
-  - [Modular](#types-modular)
   - [Generics](#types-generics)
   - [References](#types-references)
   - [Recursive](#types-recursive)
@@ -644,6 +644,28 @@ TypeBox provides an extended type set that can be used to create schematics for
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
+<a name='types-modules'></a>
+
+### Type Modules
+
+TypeBox uses a modular type system and supports selective type imports. Using selective imports can be useful in resource constrained environments as the technique allows modern bundlers to tree shake unused types. This can reduce overall bundle sizes.
+
+```typescript
+import { Object, Number, String, Boolean, type Static } from '@sinclair/typebox'
+
+const T = Object({                                   // const T: TObject<{
+  x: Number(),                                       //  x: TNumber,
+  y: String(),                                       //  y: TString,
+  z: Boolean()                                       //  z: TBoolean
+})                                                   // }>
+
+type T = Static<typeof T>                            // type T = { 
+                                                     //   x: number, 
+                                                     //   y: string, 
+                                                     //   z: boolean 
+                                                     // }
+```
+
 <a name='types-options'></a>
 
 ### Options
@@ -717,20 +739,6 @@ Object properties can be modified with Readonly and Optional. The following tabl
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name='types-modular'></a>
-
-### Modular Types
-
-TypeBox implements a modular type system. The following imports the full type system (recommended)
-
-```typescript
-import { Type } from '@sinclair/typebox'             // 36.5 kb minified
-```
-The following imports types individually which enables modern bundlers to optimize bundle sizes via tree shaking.
-```typescript
-import { Object, Number } from '@sinclair/typebox'   // 6.4 kb minified
-```
-
 <a name='types-generics'></a>
 
 ### Generic Types
@@ -950,7 +958,7 @@ const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = {
 
 ### Template Literal Types
 
-TypeBox supports Template Literal types with Type.TemplateLiteral. This type can be created using a syntax similar to the TypeScript Template Literal syntax. TypeBox encodes Template Literals as regular expression string patterns which enables the template to be checked by Json Schema validators. This type also supports regular expression parsing, enabling template patterns to be used for generative types. The following shows both TypeScript and TypeBox usage.
+TypeBox supports template literals with Type.TemplateLiteral. This type can be created using a syntax similar to the TypeScript template literal syntax or composed from exterior types. TypeBox encodes template literals as regular expression patterns which enables the template to be checked by Json Schema validators. This type also supports regular expression parsing, enabling template patterns to be used for generative types. The following shows both TypeScript and TypeBox usage.
 
 ```typescript
 // TypeScript
@@ -1808,11 +1816,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '118.3 kb' │ ' 52.4 kb' │  '2.26 x'   │
+│ typebox/compiler     │ '118.7 kb' │ ' 52.5 kb' │  '2.26 x'   │
 │ typebox/errors       │ ' 55.1 kb' │ ' 25.2 kb' │  '2.19 x'   │
 │ typebox/system       │ '  4.6 kb' │ '  2.0 kb' │  '2.31 x'   │
-│ typebox/value        │ '144.0 kb' │ ' 61.5 kb' │  '2.34 x'   │
-│ typebox              │ ' 87.0 kb' │ ' 36.5 kb' │  '2.39 x'   │
+│ typebox/value        │ '144.8 kb' │ ' 61.8 kb' │  '2.34 x'   │
+│ typebox              │ ' 87.7 kb' │ ' 36.7 kb' │  '2.39 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```