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

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

@@ -1,3 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 import { Any } from '../any/index.mjs';
 import { Array } from '../array/index.mjs';
 import { Boolean } from '../boolean/index.mjs';
@@ -39,136 +66,190 @@ import { Tuple } from '../tuple/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Unknown } from '../unknown/index.mjs';
 import { Unsafe } from '../unsafe/index.mjs';
+/** Json Type Builder with Static Resolution for TypeScript */
 export class JsonTypeBuilder {
+    // ------------------------------------------------------------------------
+    // Strict
+    // ------------------------------------------------------------------------
+    /** `[Json]` Omits compositing symbols from this schema */
     Strict(schema) {
         return Strict(schema);
     }
+    // ------------------------------------------------------------------------
+    // Modifiers
+    // ------------------------------------------------------------------------
+    /** `[Json]` Creates a Readonly and Optional property */
     ReadonlyOptional(schema) {
         return ReadonlyOptional(schema);
     }
+    /** `[Json]` Creates a Readonly property */
     Readonly(schema) {
         return Readonly(schema);
     }
+    /** `[Json]` Creates an Optional property */
     Optional(schema) {
         return Optional(schema);
     }
+    // ------------------------------------------------------------------------
+    // Types
+    // ------------------------------------------------------------------------
+    /** `[Json]` Creates an Any type */
     Any(options = {}) {
         return Any(options);
     }
+    /** `[Json]` Creates an Array type */
     Array(schema, options = {}) {
         return Array(schema, options);
     }
+    /** `[Json]` Creates a Boolean type */
     Boolean(options = {}) {
         return Boolean(options);
     }
+    /** `[Json]` Intrinsic function to Capitalize LiteralString types */
     Capitalize(schema, options = {}) {
         return Capitalize(schema, options);
     }
+    /** `[Json]` Creates a Composite object type */
     Composite(objects, options) {
-        return Composite(objects, options);
+        return Composite(objects, options); // (error) TS 5.4.0-dev - review TComposite implementation
     }
+    /** `[JavaScript]` Creates a readonly const type from the given value. */
     Const(value, options = {}) {
         return Const(value, options);
     }
+    /** `[Json]` Creates a dereferenced type */
     Deref(schema, references) {
         return Deref(schema, references);
     }
+    /** `[Json]` Creates a Enum type */
     Enum(item, options = {}) {
         return Enum(item, options);
     }
+    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
     Exclude(unionType, excludedMembers, options = {}) {
         return Exclude(unionType, excludedMembers, options);
     }
+    /** `[Json]` Creates a Conditional type */
     Extends(L, R, T, F, options = {}) {
         return Extends(L, R, T, F, options);
     }
+    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     Extract(type, union, options = {}) {
         return Extract(type, union, options);
     }
+    /** `[Json]` Returns an Indexed property type for the given keys */
     Index(schema, unresolved, options = {}) {
         return Index(schema, unresolved, options);
     }
+    /** `[Json]` Creates an Integer type */
     Integer(options = {}) {
         return Integer(options);
     }
+    /** `[Json]` Creates an Intersect type */
     Intersect(T, options = {}) {
         return Intersect(T, options);
     }
+    /** `[Json]` Creates a KeyOf type */
     KeyOf(schema, options = {}) {
         return KeyOf(schema, options);
     }
+    /** `[Json]` Creates a Literal type */
     Literal(value, options = {}) {
         return Literal(value, options);
     }
+    /** `[Json]` Intrinsic function to Lowercase LiteralString types */
     Lowercase(schema, options = {}) {
         return Lowercase(schema, options);
     }
+    /** `[Json]` Creates a Mapped object type */
     Mapped(key, map, options = {}) {
         return Mapped(key, map, options);
     }
+    /** `[Json]` Creates a Never type */
     Never(options = {}) {
         return Never(options);
     }
+    /** `[Json]` Creates a Not type */
     Not(schema, options) {
         return Not(schema, options);
     }
+    /** `[Json]` Creates a Null type */
     Null(options = {}) {
         return Null(options);
     }
+    /** `[Json]` Creates a Number type */
     Number(options = {}) {
         return Number(options);
     }
+    /** `[Json]` Creates an Object type */
     Object(properties, options = {}) {
         return Object(properties, options);
     }
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit(schema, unresolved, options = {}) {
         return Omit(schema, unresolved, options);
     }
+    /** `[Json]` Constructs a type where all properties are optional */
     Partial(schema, options = {}) {
         return Partial(schema, options);
     }
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
     Pick(schema, unresolved, options = {}) {
         return Pick(schema, unresolved, options);
     }
+    /** `[Json]` Creates a Record type */
     Record(key, schema, options = {}) {
         return Record(key, schema);
     }
+    /** `[Json]` Creates a Recursive type */
     Recursive(callback, options = {}) {
         return Recursive(callback, options);
     }
+    /** `[Json]` Creates a Ref type. */
     Ref(unresolved, options = {}) {
         return Ref(unresolved, options);
     }
+    /** `[Json]` Constructs a type where all properties are required */
     Required(schema, options = {}) {
         return Required(schema, options);
     }
+    /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
     Rest(schema) {
         return Rest(schema);
     }
+    /** `[Json]` Creates a String type */
     String(options = {}) {
         return String(options);
     }
+    /** `[Json]` Creates a TemplateLiteral type */
     TemplateLiteral(unresolved, options = {}) {
         return TemplateLiteral(unresolved, options);
     }
+    /** `[Json]` Creates a Transform type */
     Transform(schema) {
         return Transform(schema);
     }
+    /** `[Json]` Creates a Tuple type */
     Tuple(items, options = {}) {
         return Tuple(items, options);
     }
+    /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
     Uncapitalize(schema, options = {}) {
         return Uncapitalize(schema, options);
     }
+    /** `[Json]` Creates a Union type */
     Union(schemas, options = {}) {
         return Union(schemas, options);
     }
+    /** `[Json]` Creates an Unknown type */
     Unknown(options = {}) {
         return Unknown(options);
     }
+    /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
     Unsafe(options = {}) {
         return Unsafe(options);
     }
+    /** `[Json]` Intrinsic function to Uppercase LiteralString types */
     Uppercase(schema, options = {}) {
         return Uppercase(schema, options);
     }

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

@@ -1,3 +1,33 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+// ------------------------------------------------------------------
+// Type: Module
+// ------------------------------------------------------------------
 export { Any } from '../any/index.mjs';
 export { Array } from '../array/index.mjs';
 export { AsyncIterator } from '../async-iterator/index.mjs';

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

@@ -1 +1,28 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 export * from './uint8array.mjs';

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

@@ -9,4 +9,5 @@ export interface TUint8Array extends TSchema, Uint8ArrayOptions {
     static: Uint8Array;
     type: 'uint8array';
 }
+/** `[JavaScript]` Creates a Uint8Array type */
 export declare function Uint8Array(options?: Uint8ArrayOptions): TUint8Array;

package/build/import/type/uint8array/uint8array.mjs

@@ -1,4 +1,32 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a Uint8Array type */
 export function Uint8Array(options = {}) {
     return { ...options, [Kind]: 'Uint8Array', type: 'Uint8Array' };
 }

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

@@ -1 +1,28 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 export * from './undefined.mjs';

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

@@ -5,4 +5,5 @@ export interface TUndefined extends TSchema {
     static: undefined;
     type: 'undefined';
 }
+/** `[JavaScript]` Creates a Undefined type */
 export declare function Undefined(options?: SchemaOptions): TUndefined;

package/build/import/type/undefined/undefined.mjs

@@ -1,4 +1,32 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a Undefined type */
 export function Undefined(options = {}) {
     return { ...options, [Kind]: 'Undefined', type: 'undefined' };
 }

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

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

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

@@ -1 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+export * from './union-evaluated.mjs';
+export * from './union-type.mjs';
 export * from './union.mjs';

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

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

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

@@ -0,0 +1,32 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+import { CloneRest } from '../clone/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+export function UnionCreate(T, options) {
+    return { ...options, [Kind]: 'Union', anyOf: CloneRest(T) };
+}

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

@@ -0,0 +1,17 @@
+import type { SchemaOptions, TSchema } from '../schema/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
+import type { TReadonly } from '../readonly/index.mjs';
+import type { TUnion } from './union-type.mjs';
+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>);
+/** `[Json]` Creates an evaluated Union type */
+export declare function UnionEvaluated<T extends TSchema[], R = UnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R;
+export {};

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

@@ -0,0 +1,68 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+import { OptionalKind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { Discard } from '../discard/index.mjs';
+import { Never } from '../never/index.mjs';
+import { Optional } from '../optional/index.mjs';
+import { UnionCreate } from './union-create.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import { TOptional as IsOptionalType } from '../guard/type.mjs';
+// prettier-ignore
+function IsUnionOptional(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? IsOptionalType(L)
+            ? true
+            : IsUnionOptional(R)
+        : false);
+}
+// prettier-ignore
+function RemoveOptionalFromRest(T) {
+    return (T.map(T => RemoveOptionalFromType(T)));
+}
+// prettier-ignore
+function RemoveOptionalFromType(T) {
+    return (Discard(T, [OptionalKind]));
+}
+// prettier-ignore
+function ResolveUnion(T, options) {
+    return (IsUnionOptional(T)
+        ? Optional(UnionCreate(RemoveOptionalFromRest(T), options))
+        : UnionCreate(RemoveOptionalFromRest(T), options));
+}
+/** `[Json]` Creates an evaluated Union type */
+export function UnionEvaluated(T, options = {}) {
+    // prettier-ignore
+    return (T.length === 0 ? Never(options) :
+        T.length === 1 ? CloneType(T[0], options) :
+            ResolveUnion(T, options));
+}

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

@@ -0,0 +1,12 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+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/import/type/union/union-type.mjs

@@ -0,0 +1,28 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+import { Kind } from '../symbols/index.mjs';

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

@@ -1,15 +1,6 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Static } from '../static/index.mjs';
 import { type TNever } from '../never/index.mjs';
-import { OptionalFromUnion } from '../modifiers/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-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.mjs';
+export type Union<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TUnion<T>);
+/** `[Json]` Creates a Union type */
+export declare function Union<T extends TSchema[]>(T: [...T], options?: SchemaOptions): Union<T>;