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

package/build/import/index.d.mts

@@ -24,7 +24,7 @@ export { Increment, type Assert, type AssertType, type AssertRest, type AssertPr
 export { Index, IndexPropertyKeys, IndexFromMappedKey, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from './type/indexed/index.mjs';
 export { InstanceType, type TInstanceType } from './type/instance-type/index.mjs';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index.mjs';
-export { Intersect, type TIntersect, type IntersectOptions } from './type/intersect/index.mjs';
+export { Intersect, IntersectEvaluated, type TIntersect, type IntersectOptions } from './type/intersect/index.mjs';
 export { Iterator, type TIterator } from './type/iterator/index.mjs';
 export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index.mjs';
 export { KeyOf, type TKeyOf, type KeyOfFromMappedResult, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index.mjs';
@@ -60,7 +60,7 @@ export { Transform, type TTransform, type TransformOptions, type TransformFuncti
 export { Tuple, type TTuple } from './type/tuple/index.mjs';
 export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index.mjs';
 export { Undefined, type TUndefined } from './type/undefined/index.mjs';
-export { Union, type TUnion } from './type/union/index.mjs';
+export { Union, UnionEvaluated, type TUnion } from './type/union/index.mjs';
 export { Unknown, type TUnknown } from './type/unknown/index.mjs';
 export { Unsafe, type TUnsafe } from './type/unsafe/index.mjs';
 export { Void, type TVoid } from './type/void/index.mjs';

package/build/import/index.mjs

@@ -24,7 +24,7 @@ export { Increment } from './type/helpers/index.mjs';
 export { Index, IndexPropertyKeys, IndexFromMappedKey } from './type/indexed/index.mjs';
 export { InstanceType } from './type/instance-type/index.mjs';
 export { Integer } from './type/integer/index.mjs';
-export { Intersect } from './type/intersect/index.mjs';
+export { Intersect, IntersectEvaluated } from './type/intersect/index.mjs';
 export { Iterator } from './type/iterator/index.mjs';
 export { Intrinsic, IntrinsicFromMappedKey, Capitalize, Lowercase, Uncapitalize, Uppercase } from './type/intrinsic/index.mjs';
 export { KeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index.mjs';
@@ -58,7 +58,7 @@ export { Transform, TransformDecodeBuilder, TransformEncodeBuilder } from './typ
 export { Tuple } from './type/tuple/index.mjs';
 export { Uint8Array } from './type/uint8array/index.mjs';
 export { Undefined } from './type/undefined/index.mjs';
-export { Union } from './type/union/index.mjs';
+export { Union, UnionEvaluated } from './type/union/index.mjs';
 export { Unknown } from './type/unknown/index.mjs';
 export { Unsafe } from './type/unsafe/index.mjs';
 export { Void } from './type/void/index.mjs';

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

@@ -11,7 +11,7 @@ export interface ArrayOptions extends SchemaOptions {
 }
 export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
     [Kind]: 'Array';
-    static: Static<T, this['params']>[];
+    static: Array<Static<T, this['params']>>;
     type: 'array';
     items: T;
 }

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

@@ -2,12 +2,12 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Static } from '../static/index.mjs';
 import type { Ensure } from '../helpers/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-type TConstructorReturnTypeResolve<T extends TSchema, P extends unknown[]> = Static<T, P>;
-type TConstructorParametersResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TConstructorParametersResolve<R, P>] : [];
-export type TConstructorResolve<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: TConstructorParametersResolve<T, P>) => TConstructorReturnTypeResolve<U, P>>);
+type TConstructorStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>;
+type TConstructorStaticParameters<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TConstructorStaticParameters<R, P>] : [];
+export type TConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: TConstructorStaticParameters<T, P>) => TConstructorStaticReturnType<U, P>>);
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
-    static: TConstructorResolve<T, U, this['params']>;
+    static: TConstructorStatic<T, U, this['params']>;
     type: 'Constructor';
     parameters: T;
     returns: U;

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

@@ -6,15 +6,15 @@ 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 { UnionResolve } from '../union/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
 import { type TExcludeFromMappedResult } from './exclude-from-mapped-result.mjs';
-type ExcludeTemplateLiteralResult<T extends string> = UnionResolve<AssertRest<UnionToTuple<{
+type ExcludeTemplateLiteralResult<T extends string> = UnionEvaluated<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
 type ExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = (Exclude<Static<T>, Static<U>> extends infer S ? ExcludeTemplateLiteralResult<Assert<S, string>> : never);
 type ExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
     [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K];
-}[number]>> extends infer R extends TSchema[] ? UnionResolve<R> : never;
+}[number]>> extends infer R extends TSchema[] ? UnionEvaluated<R> : never;
 type ExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? ExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? ExcludeArray<S, U> : T extends U ? TNever : T;
 declare function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExcludeResolve<L, R>;
 export type TExclude<T extends TSchema, U extends TSchema> = ExcludeResolve<T, U>;

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

@@ -1,9 +1,9 @@
-import { TMappedKey as IsMappedKeyType, TMappedResult as IsMappedResultType } from '../guard/type.mjs';
 import { Union } from '../union/index.mjs';
 import { ExtendsCheck, ExtendsResult } from './extends-check.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { ExtendsFromMappedKey } from './extends-from-mapped-key.mjs';
 import { ExtendsFromMappedResult } from './extends-from-mapped-result.mjs';
+import { TMappedKey as IsMappedKeyType, TMappedResult as IsMappedResultType } from '../guard/type.mjs';
 function ExtendsResolve(left, right, trueType, falseType) {
     const R = ExtendsCheck(left, right);
     return (R === ExtendsResult.Union ? Union([trueType, falseType]) :

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

@@ -5,15 +5,15 @@ 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 { UnionResolve } from '../union/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
 import { type TExtractFromMappedResult } from './extract-from-mapped-result.mjs';
-type FromTemplateLiteralResult<T extends string> = UnionResolve<AssertRest<UnionToTuple<{
+type FromTemplateLiteralResult<T extends string> = UnionEvaluated<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
 type FromTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? FromTemplateLiteralResult<Assert<S, string>> : never;
 type FromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
     [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never;
-}[number]>> extends infer R extends TSchema[] ? UnionResolve<R> : never;
+}[number]>> extends infer R extends TSchema[] ? UnionEvaluated<R> : never;
 export type ExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T, U> : T extends TUnion<infer S> ? FromArray<S, U> : T extends U ? T : T);
 export declare function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExtractResolve<L, R>;
 export type TExtract<T extends TSchema, U extends TSchema> = ExtractResolve<T, U>;

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

@@ -2,12 +2,12 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Static } from '../static/index.mjs';
 import type { Ensure } from '../helpers/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-type FunctionReturnTypeResolve<T extends TSchema, P extends unknown[]> = Static<T, P>;
-type FunctionParametersResolve<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...FunctionParametersResolve<R, P>] : [];
-type FunctionResolve<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<(...param: FunctionParametersResolve<T, P>) => FunctionReturnTypeResolve<U, P>>);
+type FunctionStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>;
+type FunctionStaticParameters<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...FunctionStaticParameters<R, P>] : [];
+type FunctionStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<(...param: FunctionStaticParameters<T, P>) => FunctionStaticReturnType<U, P>>);
 export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Function';
-    static: FunctionResolve<T, U, this['params']>;
+    static: FunctionStatic<T, U, this['params']>;
     type: 'Function';
     parameters: T;
     returns: U;

package/build/import/type/indexed/indexed-result.d.mts

@@ -6,19 +6,19 @@ import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TTuple } from '../tuple/index.mjs';
 import { type TArray } from '../array/index.mjs';
-import { IntersectResolve } from '../intersect/index.mjs';
-import { UnionResolve } from '../union/index.mjs';
+import { IntersectEvaluated } from '../intersect/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
 type FromRest<T extends TSchema[], K extends PropertyKey> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromKey<L, K>, ...FromRest<R, K>] : []);
 declare function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromRest<T, K>;
 type FromIntersectRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [...FromIntersectRest<R>] : [L, ...FromIntersectRest<R>] : []);
 declare function FromIntersectRest<T extends TSchema[]>(T: [...T]): FromIntersectRest<T>;
-type FromIntersect<T extends TSchema[], K extends PropertyKey> = (IntersectResolve<FromIntersectRest<FromRest<T, K>>>);
+type FromIntersect<T extends TSchema[], K extends PropertyKey> = (IntersectEvaluated<FromIntersectRest<FromRest<T, K>>>);
 declare function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromIntersect<T, K>;
 type FromUnionRest<T extends TSchema[], S = T> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : FromUnionRest<R, S> : S);
 declare function FromUnionRest<T extends TSchema[]>(T: [...T], S?: [...T]): FromUnionRest<T>;
-type FromUnion<T extends TSchema[], K extends PropertyKey> = (UnionResolve<FromUnionRest<FromRest<T, K>>>);
+type FromUnion<T extends TSchema[], K extends PropertyKey> = (UnionEvaluated<FromUnionRest<FromRest<T, K>>>);
 declare function FromUnion<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromUnion<T, K>;
-type FromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? UnionResolve<T> : TNever);
+type FromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? UnionEvaluated<T> : TNever);
 declare function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromTuple<T, K>;
 type FromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
 declare function FromArray<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromArray<T, K>;
@@ -28,6 +28,6 @@ type FromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<i
 declare function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromKey<T, K>;
 type FromKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? [FromKey<T, L>, ...FromKeys<T, R>] : []);
 declare function FromKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromKeys<T, K>;
-export type TIndexResult<T extends TSchema, K extends PropertyKey[]> = (UnionResolve<FromKeys<T, K>>);
+export type TIndexResult<T extends TSchema, K extends PropertyKey[]> = (UnionEvaluated<FromKeys<T, K>>);
 export declare function IndexResult<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): TIndexResult<T, K>;
 export {};

package/build/import/type/indexed/indexed-result.mjs

@@ -1,8 +1,8 @@
 import { Never } from '../never/index.mjs';
-import { IntersectResolve } from '../intersect/index.mjs';
-import { UnionResolve } from '../union/index.mjs';
+import { IntersectEvaluated } from '../intersect/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-import { TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType, TArray as IsArrayType, TObject as IsObjectType, TNever as IsNeverType } from '../guard/type.mjs';
+import { TArray as IsArrayType, TIntersect as IsIntersectType, TObject as IsObjectType, TNever as IsNeverType, TTuple as IsTupleType, TUnion as IsUnionType } from '../guard/type.mjs';
 function FromRest(T, K) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -18,7 +18,7 @@ function FromIntersectRest(T) {
         : []);
 }
 function FromIntersect(T, K) {
-    return (IntersectResolve(FromIntersectRest(FromRest(T, K))));
+    return (IntersectEvaluated(FromIntersectRest(FromRest(T, K))));
 }
 function FromUnionRest(T, S = T) {
     const [L, ...R] = T;
@@ -29,11 +29,11 @@ function FromUnionRest(T, S = T) {
         : S);
 }
 function FromUnion(T, K) {
-    return (UnionResolve(FromUnionRest(FromRest(T, K))));
+    return (UnionEvaluated(FromUnionRest(FromRest(T, K))));
 }
 function FromTuple(T, K) {
     return (K in T ? T[K] :
-        K === '[number]' ? UnionResolve(T) :
+        K === '[number]' ? UnionEvaluated(T) :
             Never());
 }
 function FromArray(T, K) {
@@ -61,5 +61,5 @@ function FromKeys(T, K) {
         : []);
 }
 export function IndexResult(T, K, options) {
-    return (CloneType(UnionResolve(FromKeys(T, K)), options));
+    return (CloneType(UnionEvaluated(FromKeys(T, K)), options));
 }

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

@@ -1,8 +1,8 @@
-import { TSchema as IsSchemaType, TMappedKey as IsMappedKey } from '../guard/type.mjs';
 import { IndexResult } from './indexed-result.mjs';
 import { IndexPropertyKeys } from './indexed-property-keys.mjs';
 import { IndexFromMappedKey } from './indexed-from-mapped-key.mjs';
 import { CloneType } from '../clone/type.mjs';
+import { TMappedKey as IsMappedKey, TSchema as IsSchemaType } from '../guard/type.mjs';
 export function Index(T, K, options = {}) {
     return (IsMappedKey(K) ? CloneType(IndexFromMappedKey(T, K, options)) :
         IsSchemaType(K) ? IndexResult(T, IndexPropertyKeys(K), options) :

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { Kind } from '../symbols/index.mjs';
+import { CloneType, CloneRest } from '../clone/type.mjs';
+import { TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
+export function IntersectCreate(T, options) {
+    const allObjects = T.every((schema) => IsObjectType(schema));
+    const clonedUnevaluatedProperties = IsSchemaType(options.unevaluatedProperties)
+        ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) }
+        : {};
+    return ((options.unevaluatedProperties === false || IsSchemaType(options.unevaluatedProperties) || allObjects
+        ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
+        : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) }));
+}

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

@@ -0,0 +1,16 @@
+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 { TIntersect, IntersectOptions } from './intersect-type.mjs';
+type IsIntersectOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? IsIntersectOptional<R> : false : true);
+declare function IsIntersectOptional<T extends TSchema[]>(T: T): IsIntersectOptional<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 ResolveIntersect<T extends TSchema[]> = (IsIntersectOptional<T> extends true ? TOptional<TIntersect<RemoveOptionalFromRest<T>>> : TIntersect<RemoveOptionalFromRest<T>>);
+declare function ResolveIntersect<T extends TSchema[]>(T: [...T], options: SchemaOptions): ResolveIntersect<T>;
+export type IntersectEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : ResolveIntersect<T>);
+export declare function IntersectEvaluated<T extends TSchema[], R = IntersectEvaluated<T>>(T: [...T], options?: IntersectOptions): R;
+export {};

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

@@ -0,0 +1,35 @@
+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 { IntersectCreate } from './intersect-create.mjs';
+import { TOptional as IsOptionalType, TTransform as IsTransformType, } from '../guard/type.mjs';
+function IsIntersectOptional(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? IsOptionalType(L)
+            ? IsIntersectOptional(R)
+            : false
+        : true);
+}
+function RemoveOptionalFromRest(T) {
+    return (T.map(T => RemoveOptionalFromType(T)));
+}
+function RemoveOptionalFromType(T) {
+    return (Discard(T, [OptionalKind]));
+}
+function ResolveIntersect(T, options) {
+    return (IsIntersectOptional(T)
+        ? Optional(IntersectCreate(RemoveOptionalFromRest(T), options))
+        : IntersectCreate(RemoveOptionalFromRest(T), options));
+}
+export function IntersectEvaluated(T, options = {}) {
+    if (T.length === 0)
+        return Never(options);
+    if (T.length === 1)
+        return CloneType(T[0], options);
+    if (T.some((schema) => IsTransformType(schema)))
+        throw new Error('Cannot intersect transform types');
+    return ResolveIntersect(T, options);
+}

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

@@ -0,0 +1,15 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+type IntersectStatic<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? Static<L, P> & IntersectStatic<R, P> : unknown;
+export type TUnevaluatedProperties = undefined | TSchema | boolean;
+export interface IntersectOptions extends SchemaOptions {
+    unevaluatedProperties?: TUnevaluatedProperties;
+}
+export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
+    [Kind]: 'Intersect';
+    static: IntersectStatic<T, this['params']>;
+    type?: 'object';
+    allOf: [...T];
+}
+export {};

package/build/import/type/intersect/intersect-type.mjs

@@ -0,0 +1 @@
+import { Kind } from '../symbols/index.mjs';

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

@@ -1,21 +1,5 @@
-import type { TupleToIntersect, AssertType } from '../helpers/index.mjs';
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Static } from '../static/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
 import { type TNever } from '../never/index.mjs';
-import { OptionalFromIntersect } from '../modifiers/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-export type IntersectResolve<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : OptionalFromIntersect<T>);
-export declare function IntersectResolve<T extends TSchema[]>(T: T): IntersectResolve<T>;
-export type TUnevaluatedProperties = undefined | TSchema | boolean;
-export interface IntersectOptions extends SchemaOptions {
-    unevaluatedProperties?: TUnevaluatedProperties;
-}
-export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
-    [Kind]: 'Intersect';
-    static: TupleToIntersect<{
-        [K in keyof T]: Static<AssertType<T[K]>, this['params']>;
-    }>;
-    type?: 'object';
-    allOf: [...T];
-}
-export declare function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): IntersectResolve<T>;
+import { TIntersect, IntersectOptions } from './intersect-type.mjs';
+export type Intersect<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TIntersect<T>);
+export declare function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T>;

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

@@ -1,25 +1,13 @@
+import { CloneType } from '../clone/type.mjs';
 import { Never } from '../never/index.mjs';
-import { OptionalFromIntersect } from '../modifiers/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-import { CloneType, CloneRest } from '../clone/type.mjs';
-import { TTransform as IsTransformType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
-export function IntersectResolve(T) {
-    return (T.length === 0
-        ? Never()
-        : T.length === 1
-            ? T[0]
-            : OptionalFromIntersect(T));
-}
+import { IntersectCreate } from './intersect-create.mjs';
+import { TTransform as IsTransformType, } from '../guard/type.mjs';
 export function Intersect(T, options = {}) {
     if (T.length === 0)
-        return Never();
+        return Never(options);
     if (T.length === 1)
         return CloneType(T[0], options);
     if (T.some((schema) => IsTransformType(schema)))
         throw new Error('Cannot intersect transform types');
-    const allObjects = T.every((schema) => IsObjectType(schema));
-    const clonedUnevaluatedProperties = IsSchemaType(options.unevaluatedProperties) ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) } : {};
-    return (options.unevaluatedProperties === false || IsSchemaType(options.unevaluatedProperties) || allObjects
-        ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
-        : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) });
+    return IntersectCreate(T, options);
 }

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

@@ -5,11 +5,11 @@ import { type TLiteral, TLiteralValue } from '../literal/index.mjs';
 import { type TNumber } from '../number/index.mjs';
 import { type SchemaOptions } from '../schema/index.mjs';
 import { KeyOfPropertyKeys } from './keyof-property-keys.mjs';
-import { UnionResolve } from '../union/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
 import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
 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/import/type/keyof/keyof.mjs

@@ -1,7 +1,7 @@
 import { Literal } from '../literal/index.mjs';
 import { Number } from '../number/index.mjs';
 import { KeyOfPropertyKeys } from './keyof-property-keys.mjs';
-import { UnionResolve } from '../union/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { KeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
 import { TMappedResult as IsMappedResultType } from '../guard/type.mjs';
@@ -18,7 +18,7 @@ export function KeyOf(T, options = {}) {
         return KeyOfFromMappedResult(T, options);
     }
     else {
-        const K = UnionResolve(FromLiterals(KeyOfPropertyKeys(T)));
+        const K = UnionEvaluated(FromLiterals(KeyOfPropertyKeys(T)));
         return CloneType(K, options);
     }
 }

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

@@ -1,4 +1,3 @@
-import { TSchema as IsSchemaType } from '../guard/type.mjs';
 import { Kind, OptionalKind, ReadonlyKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
@@ -17,7 +16,7 @@ import { Readonly } from '../readonly/index.mjs';
 import { Tuple } from '../tuple/index.mjs';
 import { Union } from '../union/index.mjs';
 import { MappedResult } from './mapped-result.mjs';
-import { TArray as IsArrayType, TAsyncIterator as IsAsyncIteratorType, TConstructor as IsConstructorType, TFunction as IsFunctionType, TIntersect as IsIntersectType, TIterator as IsIteratorType, TReadonly as IsReadonlyType, TMappedResult as IsMappedResultType, TMappedKey as IsMappedKeyType, TObject as IsObjectType, TOptional as IsOptionalType, TPromise as IsPromiseType, TTuple as IsTupleType, TUnion as IsUnionType, } from '../guard/type.mjs';
+import { TArray as IsArrayType, TAsyncIterator as IsAsyncIteratorType, TConstructor as IsConstructorType, TFunction as IsFunctionType, TIntersect as IsIntersectType, TIterator as IsIteratorType, TReadonly as IsReadonlyType, TMappedResult as IsMappedResultType, TMappedKey as IsMappedKeyType, TObject as IsObjectType, TOptional as IsOptionalType, TPromise as IsPromiseType, TSchema as IsSchemaType, TTuple as IsTupleType, TUnion as IsUnionType, } from '../guard/type.mjs';
 function FromMappedResult(K, P) {
     return (K in P
         ? FromSchemaType(K, P[K])

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

@@ -4,8 +4,6 @@ import type { Evaluate } from '../helpers/index.mjs';
 import type { TReadonly } from '../readonly/index.mjs';
 import type { TOptional } from '../optional/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-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/import/type/record/record.d.mts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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