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

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

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Required = exports.RequiredResolve = void 0;
+exports.Required = void 0;
 const index_1 = require("../intersect/index");
 const index_2 = require("../union/index");
 const index_3 = require("../object/index");
 const index_4 = require("../symbols/index");
 const type_1 = require("../clone/type");
 const index_5 = require("../discard/index");
+const required_from_mapped_result_1 = require("./required-from-mapped-result");
 const type_2 = require("../guard/type");
 function FromIntersect(T) {
     const [L, ...R] = T;
@@ -31,10 +32,14 @@ function RequiredResolve(T) {
             (0, type_2.TObject)(T) ? (0, index_3.Object)(FromProperties(T.properties)) :
                 (0, index_3.Object)({}));
 }
-exports.RequiredResolve = RequiredResolve;
 function Required(T, options = {}) {
-    const D = (0, index_5.Discard)(T, [index_4.TransformKind, '$id', 'required']);
-    const R = (0, type_1.CloneType)(RequiredResolve(T), options);
-    return { ...D, ...R };
+    if ((0, type_2.TMappedResult)(T)) {
+        return (0, required_from_mapped_result_1.RequiredFromMappedResult)(T, options);
+    }
+    else {
+        const D = (0, index_5.Discard)(T, [index_4.TransformKind, '$id', 'required']);
+        const R = (0, type_1.CloneType)(RequiredResolve(T), options);
+        return { ...D, ...R };
+    }
 }
 exports.Required = Required;

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

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

package/build/require/type/type/json.js

@@ -79,12 +79,12 @@ class JsonTypeBuilder {
     Enum(item, options = {}) {
         return (0, index_7.Enum)(item, options);
     }
-    Extends(L, R, T, F, options = {}) {
-        return (0, index_9.Extends)(L, R, T, F, options);
-    }
     Exclude(unionType, excludedMembers, options = {}) {
         return (0, index_8.Exclude)(unionType, excludedMembers, options);
     }
+    Extends(L, R, T, F, options = {}) {
+        return (0, index_9.Extends)(L, R, T, F, options);
+    }
     Extract(type, union, options = {}) {
         return (0, index_10.Extract)(type, union, options);
     }

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-14",
+  "version": "0.32.0-dev-16",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",