typebox 1.2.18 → 1.3.0

package/build/type/engine/instantiate.mjs

@@ -2,20 +2,19 @@
 // deno-lint-ignore-file
 import { Guard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
-// Types
+// Modifiers
 // ------------------------------------------------------------------
-import { IsBase } from '../types/base.mjs';
+import { AddImmutableAction } from './immutable/instantiate_add.mjs';
+import { AddReadonlyAction } from './readonly/instantiate_add.mjs';
+import { AddOptionalAction } from './optional/instantiate_add.mjs';
 import { _Array_, IsArray, ArrayOptions } from '../types/array.mjs';
-import { AsyncIterator, IsAsyncIterator, AsyncIteratorOptions } from '../types/async_iterator.mjs';
 import { Constructor, IsConstructor, ConstructorOptions } from '../types/constructor.mjs';
 import { Deferred, IsDeferred } from '../types/deferred.mjs';
 import { _Function_, IsFunction, FunctionOptions } from '../types/function.mjs';
 import { IsCall } from '../types/call.mjs';
 import { Dependent, IsDependent, DependentOptions } from '../types/dependent.mjs';
 import { Intersect, IsIntersect, IntersectOptions } from '../types/intersect.mjs';
-import { Iterator, IsIterator, IteratorOptions } from '../types/iterator.mjs';
 import { Object, IsObject, ObjectOptions } from '../types/object.mjs';
-import { _Promise_, IsPromise, PromiseOptions } from '../types/promise.mjs';
 import { RecordFromPattern, IsRecord, RecordPattern, RecordValue } from '../types/record.mjs';
 import { Tuple, IsTuple, TupleOptions } from '../types/tuple.mjs';
 import { Union, IsUnion, UnionOptions } from '../types/union.mjs';
@@ -30,13 +29,12 @@ import { AddReadonlyInstantiate } from './readonly/instantiate_add.mjs';
 import { RemoveReadonlyInstantiate } from './readonly/instantiate_remove.mjs';
 import { AddOptionalInstantiate } from './optional/instantiate_add.mjs';
 import { RemoveOptionalInstantiate } from './optional/instantiate_remove.mjs';
-import { Optional, IsOptional } from '../types/_optional.mjs';
-import { Immutable, IsImmutable } from '../types/_immutable.mjs';
-import { Readonly, IsReadonly } from '../types/_readonly.mjs';
+import { IsOptional } from '../types/_optional.mjs';
+import { IsImmutable } from '../types/_immutable.mjs';
+import { IsReadonly } from '../types/_readonly.mjs';
 // ------------------------------------------------------------------
 // Instantiate
 // ------------------------------------------------------------------
-import { AwaitedInstantiate } from './awaited/instantiate.mjs';
 import { CallInstantiate } from './call/instantiate.mjs';
 import { CapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { ConditionalInstantiate } from './conditional/index.mjs';
@@ -87,9 +85,15 @@ export function InstantiateElements(context, state, types) {
 export function InstantiateTypes(context, state, types) {
     return types.map(type => InstantiateType(context, state, type));
 }
+function WithModifiers(type, instantiatedType) {
+    const withOptional = IsOptional(type) ? AddOptionalAction(instantiatedType, {}) : instantiatedType;
+    const withReadonly = IsReadonly(type) ? AddReadonlyAction(withOptional, {}) : withOptional;
+    const withImmutable = IsImmutable(type) ? AddImmutableAction(withReadonly, {}) : withReadonly;
+    return withImmutable;
+}
 function InstantiateDeferred(context, state, action, parameters, options) {
     return (
-    // Modifier Actions
+    // Modifiers
     Guard.IsEqual(action, 'AddImmutable') ? AddImmutableInstantiate(context, state, parameters[0], options) :
         Guard.IsEqual(action, 'RemoveImmutable') ? RemoveImmutableInstantiate(context, state, parameters[0], options) :
             Guard.IsEqual(action, 'AddReadonly') ? AddReadonlyInstantiate(context, state, parameters[0], options) :
@@ -97,66 +101,56 @@ function InstantiateDeferred(context, state, action, parameters, options) {
                     Guard.IsEqual(action, 'AddOptional') ? AddOptionalInstantiate(context, state, parameters[0], options) :
                         Guard.IsEqual(action, 'RemoveOptional') ? RemoveOptionalInstantiate(context, state, parameters[0], options) :
                             // Actions
-                            Guard.IsEqual(action, 'Awaited') ? AwaitedInstantiate(context, state, parameters[0], options) :
-                                Guard.IsEqual(action, 'Capitalize') ? CapitalizeInstantiate(context, state, parameters[0], options) :
-                                    Guard.IsEqual(action, 'Conditional') ? ConditionalInstantiate(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
-                                        Guard.IsEqual(action, 'ConstructorParameters') ? ConstructorParametersInstantiate(context, state, parameters[0], options) :
-                                            Guard.IsEqual(action, 'Evaluate') ? EvaluateInstantiate(context, state, parameters[0], options) :
-                                                Guard.IsEqual(action, 'Exclude') ? ExcludeInstantiate(context, state, parameters[0], parameters[1], options) :
-                                                    Guard.IsEqual(action, 'Extract') ? ExtractInstantiate(context, state, parameters[0], parameters[1], options) :
-                                                        Guard.IsEqual(action, 'Index') ? IndexInstantiate(context, state, parameters[0], parameters[1], options) :
-                                                            Guard.IsEqual(action, 'InstanceType') ? InstanceTypeInstantiate(context, state, parameters[0], options) :
-                                                                Guard.IsEqual(action, 'Interface') ? InterfaceInstantiate(context, state, parameters[0], parameters[1], options) :
-                                                                    Guard.IsEqual(action, 'KeyOf') ? KeyOfInstantiate(context, state, parameters[0], options) :
-                                                                        Guard.IsEqual(action, 'Lowercase') ? LowercaseInstantiate(context, state, parameters[0], options) :
-                                                                            Guard.IsEqual(action, 'Mapped') ? MappedInstantiate(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
-                                                                                Guard.IsEqual(action, 'Module') ? ModuleInstantiate(context, state, parameters[0], options) :
-                                                                                    Guard.IsEqual(action, 'NonNullable') ? NonNullableInstantiate(context, state, parameters[0], options) :
-                                                                                        Guard.IsEqual(action, 'Pick') ? PickInstantiate(context, state, parameters[0], parameters[1], options) :
-                                                                                            Guard.IsEqual(action, 'Parameters') ? ParametersInstantiate(context, state, parameters[0], options) :
-                                                                                                Guard.IsEqual(action, 'Partial') ? PartialInstantiate(context, state, parameters[0], options) :
-                                                                                                    Guard.IsEqual(action, 'Omit') ? OmitInstantiate(context, state, parameters[0], parameters[1], options) :
-                                                                                                        Guard.IsEqual(action, 'ReadonlyObject') ? ReadonlyObjectInstantiate(context, state, parameters[0], options) :
-                                                                                                            Guard.IsEqual(action, 'Record') ? RecordInstantiate(context, state, parameters[0], parameters[1], options) :
-                                                                                                                Guard.IsEqual(action, 'Required') ? RequiredInstantiate(context, state, parameters[0], options) :
-                                                                                                                    Guard.IsEqual(action, 'ReturnType') ? ReturnTypeInstantiate(context, state, parameters[0], options) :
-                                                                                                                        Guard.IsEqual(action, 'TemplateLiteral') ? TemplateLiteralInstantiate(context, state, parameters[0], options) :
-                                                                                                                            Guard.IsEqual(action, 'Uncapitalize') ? UncapitalizeInstantiate(context, state, parameters[0], options) :
-                                                                                                                                Guard.IsEqual(action, 'Uppercase') ? UppercaseInstantiate(context, state, parameters[0], options) :
-                                                                                                                                    Guard.IsEqual(action, 'With') ? WithInstantiate(context, state, parameters[0], parameters[1]) :
-                                                                                                                                        Deferred(action, parameters, options));
+                            Guard.IsEqual(action, 'Capitalize') ? CapitalizeInstantiate(context, state, parameters[0], options) :
+                                Guard.IsEqual(action, 'Conditional') ? ConditionalInstantiate(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
+                                    Guard.IsEqual(action, 'ConstructorParameters') ? ConstructorParametersInstantiate(context, state, parameters[0], options) :
+                                        Guard.IsEqual(action, 'Evaluate') ? EvaluateInstantiate(context, state, parameters[0], options) :
+                                            Guard.IsEqual(action, 'Exclude') ? ExcludeInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                Guard.IsEqual(action, 'Extract') ? ExtractInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                    Guard.IsEqual(action, 'Index') ? IndexInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                        Guard.IsEqual(action, 'InstanceType') ? InstanceTypeInstantiate(context, state, parameters[0], options) :
+                                                            Guard.IsEqual(action, 'Interface') ? InterfaceInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                Guard.IsEqual(action, 'KeyOf') ? KeyOfInstantiate(context, state, parameters[0], options) :
+                                                                    Guard.IsEqual(action, 'Lowercase') ? LowercaseInstantiate(context, state, parameters[0], options) :
+                                                                        Guard.IsEqual(action, 'Mapped') ? MappedInstantiate(context, state, parameters[0], parameters[1], parameters[2], parameters[3], options) :
+                                                                            Guard.IsEqual(action, 'Module') ? ModuleInstantiate(context, state, parameters[0], options) :
+                                                                                Guard.IsEqual(action, 'NonNullable') ? NonNullableInstantiate(context, state, parameters[0], options) :
+                                                                                    Guard.IsEqual(action, 'Pick') ? PickInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                                        Guard.IsEqual(action, 'Parameters') ? ParametersInstantiate(context, state, parameters[0], options) :
+                                                                                            Guard.IsEqual(action, 'Partial') ? PartialInstantiate(context, state, parameters[0], options) :
+                                                                                                Guard.IsEqual(action, 'Omit') ? OmitInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                                                    Guard.IsEqual(action, 'ReadonlyObject') ? ReadonlyObjectInstantiate(context, state, parameters[0], options) :
+                                                                                                        Guard.IsEqual(action, 'Record') ? RecordInstantiate(context, state, parameters[0], parameters[1], options) :
+                                                                                                            Guard.IsEqual(action, 'Required') ? RequiredInstantiate(context, state, parameters[0], options) :
+                                                                                                                Guard.IsEqual(action, 'ReturnType') ? ReturnTypeInstantiate(context, state, parameters[0], options) :
+                                                                                                                    Guard.IsEqual(action, 'TemplateLiteral') ? TemplateLiteralInstantiate(context, state, parameters[0], options) :
+                                                                                                                        Guard.IsEqual(action, 'Uncapitalize') ? UncapitalizeInstantiate(context, state, parameters[0], options) :
+                                                                                                                            Guard.IsEqual(action, 'Uppercase') ? UppercaseInstantiate(context, state, parameters[0], options) :
+                                                                                                                                Guard.IsEqual(action, 'With') ? WithInstantiate(context, state, parameters[0], parameters[1]) :
+                                                                                                                                    Deferred(action, parameters, options));
 }
-export function InstantiateImmediate(context, state, type) {
-    type = (IsBase(type) ? type.Clone() : type);
-    const result = (IsRef(type) ? RefInstantiate(context, state, type, type.$ref) :
+function InstantiateImmediate(context, state, type) {
+    const instantiatedType = (IsRef(type) ? RefInstantiate(context, state, type, type.$ref) :
         IsArray(type) ? _Array_(InstantiateType(context, state, type.items), ArrayOptions(type)) :
-            IsAsyncIterator(type) ? AsyncIterator(InstantiateType(context, state, type.iteratorItems), AsyncIteratorOptions(type)) :
-                IsCall(type) ? CallInstantiate(context, state, type.target, type.arguments) :
-                    IsConstructor(type) ? Constructor(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.instanceType), ConstructorOptions(type)) :
-                        IsDeferred(type) ? InstantiateDeferred(context, state, type.action, type.parameters, type.options) :
-                            IsFunction(type) ? _Function_(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.returnType), FunctionOptions(type)) :
-                                IsDependent(type) ? Dependent(InstantiateType(context, state, type.if), InstantiateType(context, state, type.then), InstantiateType(context, state, type.else), DependentOptions(type)) :
-                                    IsIntersect(type) ? Intersect(InstantiateTypes(context, state, type.allOf), IntersectOptions(type)) :
-                                        IsIterator(type) ? Iterator(InstantiateType(context, state, type.iteratorItems), IteratorOptions(type)) :
-                                            IsObject(type) ? Object(InstantiateProperties(context, state, type.properties), ObjectOptions(type)) :
-                                                IsPromise(type) ? _Promise_(InstantiateType(context, state, type.item), PromiseOptions(type)) :
-                                                    IsRecord(type) ? RecordFromPattern(RecordPattern(type), InstantiateType(context, state, RecordValue(type))) :
-                                                        IsRest(type) ? Rest(InstantiateType(context, state, type.items)) :
-                                                            IsTuple(type) ? Tuple(InstantiateElements(context, state, type.items), TupleOptions(type)) :
-                                                                IsUnion(type) ? Union(InstantiateTypes(context, state, type.anyOf), UnionOptions(type)) :
-                                                                    type);
-    return result;
-}
-function WithModifiers(type, instantiatedType) {
-    const withImmutable = IsImmutable(type) ? Immutable(instantiatedType) : instantiatedType;
-    const withReadonly = IsReadonly(type) ? Readonly(withImmutable) : withImmutable;
-    const withOptional = IsOptional(type) ? Optional(withReadonly) : withReadonly;
-    return withOptional;
+            IsCall(type) ? CallInstantiate(context, state, type.target, type.arguments) :
+                IsConstructor(type) ? Constructor(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.instanceType), ConstructorOptions(type)) :
+                    IsFunction(type) ? _Function_(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.returnType), FunctionOptions(type)) :
+                        IsDependent(type) ? Dependent(InstantiateType(context, state, type.if), InstantiateType(context, state, type.then), InstantiateType(context, state, type.else), DependentOptions(type)) :
+                            IsIntersect(type) ? Intersect(InstantiateTypes(context, state, type.allOf), IntersectOptions(type)) :
+                                IsObject(type) ? Object(InstantiateProperties(context, state, type.properties), ObjectOptions(type)) :
+                                    IsRecord(type) ? RecordFromPattern(RecordPattern(type), InstantiateType(context, state, RecordValue(type))) :
+                                        IsRest(type) ? Rest(InstantiateType(context, state, type.items)) :
+                                            IsTuple(type) ? Tuple(InstantiateElements(context, state, type.items), TupleOptions(type)) :
+                                                IsUnion(type) ? Union(InstantiateTypes(context, state, type.anyOf), UnionOptions(type)) :
+                                                    type);
+    const withModifiers = WithModifiers(type, instantiatedType);
+    return withModifiers;
 }
 export function InstantiateType(context, state, type) {
-    const instantiatedType = InstantiateImmediate(context, state, type);
-    const withModifiers = IsDeferred(type) ? instantiatedType : WithModifiers(type, instantiatedType);
-    return withModifiers;
+    const result = IsDeferred(type)
+        ? InstantiateDeferred(context, state, type.action, type.parameters, type.options)
+        : InstantiateImmediate(context, state, type);
+    return result;
 }
 /** Instantiates computed schematics using the given context and type. */
 export function Instantiate(context, type) {

package/build/type/engine/keyof/instantiate.d.mts

@@ -8,7 +8,7 @@ import { type TKeyOfDeferred } from '../../action/keyof.mjs';
 import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TCollapseToObject } from '../object/index.mjs';
 import { type TFromType } from './from_type.mjs';
-type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TDependent | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
+type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic ? TCollapseToObject<Type> : Type extends TDependent ? TCollapseToObject<Type> : Type extends TIntersect ? TCollapseToObject<Type> : Type extends TUnion ? TCollapseToObject<Type> : Type)> = Result;
 export type TKeyOfAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TFromType<TNormalizeType<Type>> : TKeyOfDeferred<Type>> = Result;
 export declare function KeyOfAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TKeyOfAction<Type>;
 export type TKeyOfInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TKeyOfAction<InstantiatedType>;

package/build/type/engine/keyof/instantiate.mjs

@@ -12,7 +12,10 @@ import { CollapseToObject } from '../object/index.mjs';
 // ------------------------------------------------------------------
 import { FromType } from './from_type.mjs';
 function NormalizeType(type) {
-    const result = (IsCyclic(type) || IsDependent(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) : type);
+    const result = (IsCyclic(type) ||
+        IsDependent(type) ||
+        IsIntersect(type) ||
+        IsUnion(type)) ? CollapseToObject(type) : type;
     return result;
 }
 export function KeyOfAction(type, options) {

package/build/type/engine/this/expand_this.d.mts

@@ -1,18 +1,15 @@
 import { type TArray } from '../../types/array.mjs';
-import { type TAsyncIterator } from '../../types/async_iterator.mjs';
 import { type TConstructor } from '../../types/constructor.mjs';
 import { type TFunction } from '../../types/function.mjs';
-import { type TIterator } from '../../types/iterator.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TSchema } from '../../types/schema.mjs';
-import { type TPromise } from '../../types/promise.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TThis } from '../../types/this.mjs';
 import { type TUnion } from '../../types/union.mjs';
 type TFromTypes<Properties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Properties, Right, [...Result, TFromType<Properties, Left>]> : Result);
-export type TFromType<Properties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TArray<TFromType<Properties, Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TFromType<Properties, Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TFromTypes<Properties, Parameters>, TFromType<Properties, InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Properties, Parameters>, TFromType<Properties, ReturnType>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TFromType<Properties, Type>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TFromType<Properties, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Properties, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Properties, Types>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Properties, Types>> : Type extends TThis ? TObject<Properties> : Type);
+export type TFromType<Properties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TArray<TFromType<Properties, Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TFromTypes<Properties, Parameters>, TFromType<Properties, InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Properties, Parameters>, TFromType<Properties, ReturnType>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Properties, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Properties, Types>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Properties, Types>> : Type extends TThis ? TObject<Properties> : Type);
 export declare function FromType<Properties extends TProperties, Type extends TSchema>(properties: Properties, type: Type): TFromType<Properties, Type>;
 export type TExpandThis<Properties extends TProperties, Type extends TSchema, Result extends TSchema = TFromType<Properties, Type>> = Result;
 export declare function ExpandThis<Properties extends TProperties, Type extends TSchema>(properties: TProperties, type: Type): TExpandThis<Properties, Type>;

package/build/type/engine/this/expand_this.mjs

@@ -1,12 +1,9 @@
 // deno-fmt-ignore-file
 import { IsArray, _Array_ } from '../../types/array.mjs';
-import { IsAsyncIterator, AsyncIterator } from '../../types/async_iterator.mjs';
 import { IsConstructor, Constructor } from '../../types/constructor.mjs';
 import { IsFunction, _Function_ } from '../../types/function.mjs';
-import { IsIterator, Iterator } from '../../types/iterator.mjs';
 import { IsIntersect, Intersect } from '../../types/intersect.mjs';
 import { _Object_ } from '../../types/object.mjs';
-import { IsPromise, Promise } from '../../types/promise.mjs';
 import { IsTuple, Tuple } from '../../types/tuple.mjs';
 import { IsThis } from '../../types/this.mjs';
 import { IsUnion, Union } from '../../types/union.mjs';
@@ -15,16 +12,13 @@ function FromTypes(properties, types) {
 }
 export function FromType(properties, type) {
     return (IsArray(type) ? _Array_(FromType(properties, type.items)) :
-        IsAsyncIterator(type) ? AsyncIterator(FromType(properties, type.iteratorItems)) :
-            IsConstructor(type) ? Constructor(FromTypes(properties, type.parameters), FromType(properties, type.instanceType)) :
-                IsFunction(type) ? _Function_(FromTypes(properties, type.parameters), FromType(properties, type.returnType)) :
-                    IsIterator(type) ? Iterator(FromType(properties, type.iteratorItems)) :
-                        IsPromise(type) ? Promise(FromType(properties, type.item)) :
-                            IsTuple(type) ? Tuple(FromTypes(properties, type.items)) :
-                                IsUnion(type) ? Union(FromTypes(properties, type.anyOf)) :
-                                    IsIntersect(type) ? Intersect(FromTypes(properties, type.allOf)) :
-                                        IsThis(type) ? _Object_(properties) :
-                                            type);
+        IsConstructor(type) ? Constructor(FromTypes(properties, type.parameters), FromType(properties, type.instanceType)) :
+            IsFunction(type) ? _Function_(FromTypes(properties, type.parameters), FromType(properties, type.returnType)) :
+                IsTuple(type) ? Tuple(FromTypes(properties, type.items)) :
+                    IsUnion(type) ? Union(FromTypes(properties, type.anyOf)) :
+                        IsIntersect(type) ? Intersect(FromTypes(properties, type.allOf)) :
+                            IsThis(type) ? _Object_(properties) :
+                                type);
 }
 export function ExpandThis(properties, type) {
     const result = FromType(properties, type);

package/build/type/extends/extends_left.d.mts

@@ -1,6 +1,5 @@
 import { type TExtendsAny } from './any.mjs';
 import { type TExtendsArray } from './array.mjs';
-import { type TExtendsAsyncIterator } from './async_iterator.mjs';
 import { type TExtendsBigInt } from './bigint.mjs';
 import { type TExtendsBoolean } from './boolean.mjs';
 import { type TExtendsConstructor } from './constructor.mjs';
@@ -9,13 +8,11 @@ import { type TExtendsEnum } from './enum.mjs';
 import { type TExtendsFunction } from './function.mjs';
 import { type TExtendsInteger } from './integer.mjs';
 import { type TExtendsIntersect } from './intersect.mjs';
-import { type TExtendsIterator } from './iterator.mjs';
 import { type TExtendsLiteral } from './literal.mjs';
 import { type TExtendsNever } from './never.mjs';
 import { type TExtendsNull } from './null.mjs';
 import { type TExtendsNumber } from './number.mjs';
 import { type TExtendsObject } from './object.mjs';
-import { type TExtendsPromise } from './promise.mjs';
 import { type TExtendsRecord } from './record.mjs';
 import { type TExtendsString } from './string.mjs';
 import { type TExtendsSymbol } from './symbol.mjs';
@@ -27,7 +24,6 @@ import { type TExtendsUnknown } from './unknown.mjs';
 import { type TExtendsVoid } from './void.mjs';
 import { type TAny } from '../types/any.mjs';
 import { type TArray } from '../types/array.mjs';
-import { type TAsyncIterator } from '../types/async_iterator.mjs';
 import { type TBigInt } from '../types/bigint.mjs';
 import { type TBoolean } from '../types/boolean.mjs';
 import { type TConstructor } from '../types/constructor.mjs';
@@ -36,13 +32,11 @@ import { type TEnum, type TEnumValue } from '../types/enum.mjs';
 import { type TFunction } from '../types/function.mjs';
 import { type TInteger } from '../types/integer.mjs';
 import { type TIntersect } from '../types/intersect.mjs';
-import { type TIterator } from '../types/iterator.mjs';
 import { type TLiteral } from '../types/literal.mjs';
 import { type TNever } from '../types/never.mjs';
 import { type TNull } from '../types/null.mjs';
 import { type TNumber } from '../types/number.mjs';
 import { type TObject } from '../types/object.mjs';
-import { type TPromise } from '../types/promise.mjs';
 import { type TRecord } from '../types/record.mjs';
 import { type TSchema } from '../types/schema.mjs';
 import { type TString } from '../types/string.mjs';
@@ -55,5 +49,5 @@ import { type TProperties } from '../types/properties.mjs';
 import { type TUnion } from '../types/union.mjs';
 import { type TVoid } from '../types/void.mjs';
 import * as Result from './result.mjs';
-export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TAny ? TExtendsAny<Inferred, Left, Right> : Left extends TArray<infer Items extends TSchema> ? TExtendsArray<Inferred, Left, Items, Right> : Left extends TAsyncIterator<infer Type extends TSchema> ? TExtendsAsyncIterator<Inferred, Type, Right> : Left extends TBigInt ? TExtendsBigInt<Inferred, Left, Right> : Left extends TBoolean ? TExtendsBoolean<Inferred, Left, Right> : Left extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TExtendsConstructor<Inferred, Parameters, InstanceType, Right> : Left extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TExtendsDependent<Inferred, If, Then, Else, Right> : Left extends TEnum<infer Values extends TEnumValue[]> ? TExtendsEnum<Inferred, Values, Right> : Left extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TExtendsFunction<Inferred, Parameters, ReturnType, Right> : Left extends TInteger ? TExtendsInteger<Inferred, Left, Right> : Left extends TIntersect<infer Types extends TSchema[]> ? TExtendsIntersect<Inferred, Types, Right> : Left extends TIterator<infer Type extends TSchema> ? TExtendsIterator<Inferred, Type, Right> : Left extends TLiteral ? TExtendsLiteral<Inferred, Left, Right> : Left extends TNever ? TExtendsNever<Inferred, Left, Right> : Left extends TNull ? TExtendsNull<Inferred, Left, Right> : Left extends TNumber ? TExtendsNumber<Inferred, Left, Right> : Left extends TObject<infer Properties extends TProperties> ? TExtendsObject<Inferred, Properties, Right> : Left extends TPromise<infer Type extends TSchema> ? TExtendsPromise<Inferred, Type, Right> : Left extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TExtendsRecord<Inferred, Pattern, Value, Right> : Left extends TString ? TExtendsString<Inferred, Left, Right> : Left extends TSymbol ? TExtendsSymbol<Inferred, Left, Right> : Left extends TTemplateLiteral<infer Pattern extends string> ? TExtendsTemplateLiteral<Inferred, Pattern, Right> : Left extends TTuple<infer Types extends TSchema[]> ? TExtendsTuple<Inferred, Types, Right> : Left extends TUndefined ? TExtendsUndefined<Inferred, Left, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtendsUnion<Inferred, Types, Right> : Left extends TUnknown ? TExtendsUnknown<Inferred, Left, Right> : Left extends TVoid ? TExtendsVoid<Inferred, Left, Right> : Result.TExtendsFalse);
+export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TAny ? TExtendsAny<Inferred, Left, Right> : Left extends TArray<infer Items extends TSchema> ? TExtendsArray<Inferred, Left, Items, Right> : Left extends TBigInt ? TExtendsBigInt<Inferred, Left, Right> : Left extends TBoolean ? TExtendsBoolean<Inferred, Left, Right> : Left extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TExtendsConstructor<Inferred, Parameters, InstanceType, Right> : Left extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TExtendsDependent<Inferred, If, Then, Else, Right> : Left extends TEnum<infer Values extends TEnumValue[]> ? TExtendsEnum<Inferred, Values, Right> : Left extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TExtendsFunction<Inferred, Parameters, ReturnType, Right> : Left extends TInteger ? TExtendsInteger<Inferred, Left, Right> : Left extends TIntersect<infer Types extends TSchema[]> ? TExtendsIntersect<Inferred, Types, Right> : Left extends TLiteral ? TExtendsLiteral<Inferred, Left, Right> : Left extends TNever ? TExtendsNever<Inferred, Left, Right> : Left extends TNull ? TExtendsNull<Inferred, Left, Right> : Left extends TNumber ? TExtendsNumber<Inferred, Left, Right> : Left extends TObject<infer Properties extends TProperties> ? TExtendsObject<Inferred, Properties, Right> : Left extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TExtendsRecord<Inferred, Pattern, Value, Right> : Left extends TString ? TExtendsString<Inferred, Left, Right> : Left extends TSymbol ? TExtendsSymbol<Inferred, Left, Right> : Left extends TTemplateLiteral<infer Pattern extends string> ? TExtendsTemplateLiteral<Inferred, Pattern, Right> : Left extends TTuple<infer Types extends TSchema[]> ? TExtendsTuple<Inferred, Types, Right> : Left extends TUndefined ? TExtendsUndefined<Inferred, Left, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtendsUnion<Inferred, Types, Right> : Left extends TUnknown ? TExtendsUnknown<Inferred, Left, Right> : Left extends TVoid ? TExtendsVoid<Inferred, Left, Right> : Result.TExtendsFalse);
 export declare function ExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsLeft<Inferred, Left, Right>;

package/build/type/extends/extends_left.mjs

@@ -1,7 +1,6 @@
 // deno-fmt-ignore-file
 import { ExtendsAny } from './any.mjs';
 import { ExtendsArray } from './array.mjs';
-import { ExtendsAsyncIterator } from './async_iterator.mjs';
 import { ExtendsBigInt } from './bigint.mjs';
 import { ExtendsBoolean } from './boolean.mjs';
 import { ExtendsConstructor } from './constructor.mjs';
@@ -10,13 +9,11 @@ import { ExtendsEnum } from './enum.mjs';
 import { ExtendsFunction } from './function.mjs';
 import { ExtendsInteger } from './integer.mjs';
 import { ExtendsIntersect } from './intersect.mjs';
-import { ExtendsIterator } from './iterator.mjs';
 import { ExtendsLiteral } from './literal.mjs';
 import { ExtendsNever } from './never.mjs';
 import { ExtendsNull } from './null.mjs';
 import { ExtendsNumber } from './number.mjs';
 import { ExtendsObject } from './object.mjs';
-import { ExtendsPromise } from './promise.mjs';
 import { ExtendsRecord } from './record.mjs';
 import { ExtendsString } from './string.mjs';
 import { ExtendsSymbol } from './symbol.mjs';
@@ -31,7 +28,6 @@ import { ExtendsVoid } from './void.mjs';
 // ----------------------------------------------------------------------------
 import { IsAny } from '../types/any.mjs';
 import { IsArray } from '../types/array.mjs';
-import { IsAsyncIterator } from '../types/async_iterator.mjs';
 import { IsBigInt } from '../types/bigint.mjs';
 import { IsBoolean } from '../types/boolean.mjs';
 import { IsConstructor } from '../types/constructor.mjs';
@@ -40,13 +36,11 @@ import { IsEnum } from '../types/enum.mjs';
 import { IsFunction } from '../types/function.mjs';
 import { IsInteger } from '../types/integer.mjs';
 import { IsIntersect } from '../types/intersect.mjs';
-import { IsIterator } from '../types/iterator.mjs';
 import { IsLiteral } from '../types/literal.mjs';
 import { IsNever } from '../types/never.mjs';
 import { IsNull } from '../types/null.mjs';
 import { IsNumber } from '../types/number.mjs';
 import { IsObject } from '../types/object.mjs';
-import { IsPromise } from '../types/promise.mjs';
 import { IsRecord, RecordPattern, RecordValue } from '../types/record.mjs';
 import { IsString } from '../types/string.mjs';
 import { IsSymbol } from '../types/symbol.mjs';
@@ -60,30 +54,27 @@ import * as Result from './result.mjs';
 export function ExtendsLeft(inferred, left, right) {
     return (IsAny(left) ? ExtendsAny(inferred, left, right) :
         IsArray(left) ? ExtendsArray(inferred, left, left.items, right) :
-            IsAsyncIterator(left) ? ExtendsAsyncIterator(inferred, left.iteratorItems, right) :
-                IsBigInt(left) ? ExtendsBigInt(inferred, left, right) :
-                    IsBoolean(left) ? ExtendsBoolean(inferred, left, right) :
-                        IsConstructor(left) ? ExtendsConstructor(inferred, left.parameters, left.instanceType, right) :
-                            IsDependent(left) ? ExtendsDependent(inferred, left.if, left.then, left.else, right) :
-                                IsEnum(left) ? ExtendsEnum(inferred, left.enum, right) :
-                                    IsFunction(left) ? ExtendsFunction(inferred, left.parameters, left.returnType, right) :
-                                        IsInteger(left) ? ExtendsInteger(inferred, left, right) :
-                                            IsIntersect(left) ? ExtendsIntersect(inferred, left.allOf, right) :
-                                                IsIterator(left) ? ExtendsIterator(inferred, left.iteratorItems, right) :
-                                                    IsLiteral(left) ? ExtendsLiteral(inferred, left, right) :
-                                                        IsNever(left) ? ExtendsNever(inferred, left, right) :
-                                                            IsNull(left) ? ExtendsNull(inferred, left, right) :
-                                                                IsNumber(left) ? ExtendsNumber(inferred, left, right) :
-                                                                    IsObject(left) ? ExtendsObject(inferred, left.properties, right) :
-                                                                        IsPromise(left) ? ExtendsPromise(inferred, left.item, right) :
-                                                                            IsRecord(left) ? ExtendsRecord(inferred, RecordPattern(left), RecordValue(left), right) :
-                                                                                IsString(left) ? ExtendsString(inferred, left, right) :
-                                                                                    IsSymbol(left) ? ExtendsSymbol(inferred, left, right) :
-                                                                                        IsTemplateLiteral(left) ? ExtendsTemplateLiteral(inferred, left.pattern, right) :
-                                                                                            IsTuple(left) ? ExtendsTuple(inferred, left.items, right) :
-                                                                                                IsUndefined(left) ? ExtendsUndefined(inferred, left, right) :
-                                                                                                    IsUnion(left) ? ExtendsUnion(inferred, left.anyOf, right) :
-                                                                                                        IsUnknown(left) ? ExtendsUnknown(inferred, left, right) :
-                                                                                                            IsVoid(left) ? ExtendsVoid(inferred, left, right) :
-                                                                                                                Result.ExtendsFalse());
+            IsBigInt(left) ? ExtendsBigInt(inferred, left, right) :
+                IsBoolean(left) ? ExtendsBoolean(inferred, left, right) :
+                    IsConstructor(left) ? ExtendsConstructor(inferred, left.parameters, left.instanceType, right) :
+                        IsDependent(left) ? ExtendsDependent(inferred, left.if, left.then, left.else, right) :
+                            IsEnum(left) ? ExtendsEnum(inferred, left.enum, right) :
+                                IsFunction(left) ? ExtendsFunction(inferred, left.parameters, left.returnType, right) :
+                                    IsInteger(left) ? ExtendsInteger(inferred, left, right) :
+                                        IsIntersect(left) ? ExtendsIntersect(inferred, left.allOf, right) :
+                                            IsLiteral(left) ? ExtendsLiteral(inferred, left, right) :
+                                                IsNever(left) ? ExtendsNever(inferred, left, right) :
+                                                    IsNull(left) ? ExtendsNull(inferred, left, right) :
+                                                        IsNumber(left) ? ExtendsNumber(inferred, left, right) :
+                                                            IsObject(left) ? ExtendsObject(inferred, left.properties, right) :
+                                                                IsRecord(left) ? ExtendsRecord(inferred, RecordPattern(left), RecordValue(left), right) :
+                                                                    IsString(left) ? ExtendsString(inferred, left, right) :
+                                                                        IsSymbol(left) ? ExtendsSymbol(inferred, left, right) :
+                                                                            IsTemplateLiteral(left) ? ExtendsTemplateLiteral(inferred, left.pattern, right) :
+                                                                                IsTuple(left) ? ExtendsTuple(inferred, left.items, right) :
+                                                                                    IsUndefined(left) ? ExtendsUndefined(inferred, left, right) :
+                                                                                        IsUnion(left) ? ExtendsUnion(inferred, left.anyOf, right) :
+                                                                                            IsUnknown(left) ? ExtendsUnknown(inferred, left, right) :
+                                                                                                IsVoid(left) ? ExtendsVoid(inferred, left, right) :
+                                                                                                    Result.ExtendsFalse());
 }

package/build/type/script/mapping.d.mts

@@ -7,18 +7,6 @@ type TIntrinsicOrCall<Target extends string, Parameters extends T.TSchema[]> = (
 ] extends ['Array', [infer Type extends T.TSchema]] ? T.TArray<Type> : [
     Target,
     Parameters
-] extends ['AsyncIterator', [infer Type extends T.TSchema]] ? T.TAsyncIterator<Type> : [
-    Target,
-    Parameters
-] extends ['Promise', [infer Type extends T.TSchema]] ? T.TPromise<Type> : [
-    Target,
-    Parameters
-] extends ['Iterator', [infer Type extends T.TSchema]] ? T.TIterator<Type> : [
-    Target,
-    Parameters
-] extends ['Awaited', [infer Type extends T.TSchema]] ? S.TAwaitedDeferred<Type> : [
-    Target,
-    Parameters
 ] extends ['Capitalize', [infer Type extends T.TSchema]] ? S.TCapitalizeDeferred<Type> : [
     Target,
     Parameters

package/build/type/script/mapping.mjs

@@ -9,31 +9,27 @@ function IntrinsicOrCall(ref, parameters) {
     //
     // Have extensively tested but reports show no Omit coverage (review)
     return (Guard.IsEqual(ref, 'Array') ? T.Array(parameters[0]) :
-        Guard.IsEqual(ref, 'AsyncIterator') ? T.AsyncIterator(parameters[0]) :
-            Guard.IsEqual(ref, 'Iterator') ? T.Iterator(parameters[0]) :
-                Guard.IsEqual(ref, 'Promise') ? T.Promise(parameters[0]) :
-                    Guard.IsEqual(ref, 'Awaited') ? S.AwaitedDeferred(parameters[0]) :
-                        Guard.IsEqual(ref, 'Capitalize') ? S.CapitalizeDeferred(parameters[0]) :
-                            Guard.IsEqual(ref, 'ConstructorParameters') ? S.ConstructorParametersDeferred(parameters[0]) :
-                                Guard.IsEqual(ref, 'Evaluate') ? S.EvaluateDeferred(parameters[0]) :
-                                    Guard.IsEqual(ref, 'Exclude') ? S.ExcludeDeferred(parameters[0], parameters[1]) :
-                                        Guard.IsEqual(ref, 'Extract') ? S.ExtractDeferred(parameters[0], parameters[1]) :
-                                            Guard.IsEqual(ref, 'Index') ? S.IndexDeferred(parameters[0], parameters[1]) :
-                                                Guard.IsEqual(ref, 'InstanceType') ? S.InstanceTypeDeferred(parameters[0]) :
-                                                    Guard.IsEqual(ref, 'Lowercase') ? S.LowercaseDeferred(parameters[0]) :
-                                                        Guard.IsEqual(ref, 'NonNullable') ? S.NonNullableDeferred(parameters[0]) :
-                                                            Guard.IsEqual(ref, 'Omit') ? S.OmitDeferred(parameters[0], parameters[1]) :
-                                                                Guard.IsEqual(ref, 'Parameters') ? S.ParametersDeferred(parameters[0]) :
-                                                                    Guard.IsEqual(ref, 'Partial') ? S.PartialDeferred(parameters[0]) :
-                                                                        Guard.IsEqual(ref, 'Pick') ? S.PickDeferred(parameters[0], parameters[1]) :
-                                                                            Guard.IsEqual(ref, 'Readonly') ? S.ReadonlyObjectDeferred(parameters[0]) :
-                                                                                Guard.IsEqual(ref, 'KeyOf') ? S.KeyOfDeferred(parameters[0]) :
-                                                                                    Guard.IsEqual(ref, 'Record') ? T.RecordDeferred(parameters[0], parameters[1]) :
-                                                                                        Guard.IsEqual(ref, 'Required') ? S.RequiredDeferred(parameters[0]) :
-                                                                                            Guard.IsEqual(ref, 'ReturnType') ? S.ReturnTypeDeferred(parameters[0]) :
-                                                                                                Guard.IsEqual(ref, 'Uncapitalize') ? S.UncapitalizeDeferred(parameters[0]) :
-                                                                                                    Guard.IsEqual(ref, 'Uppercase') ? S.UppercaseDeferred(parameters[0]) :
-                                                                                                        T.CallConstruct(T.Ref(ref), parameters));
+        Guard.IsEqual(ref, 'Capitalize') ? S.CapitalizeDeferred(parameters[0]) :
+            Guard.IsEqual(ref, 'ConstructorParameters') ? S.ConstructorParametersDeferred(parameters[0]) :
+                Guard.IsEqual(ref, 'Evaluate') ? S.EvaluateDeferred(parameters[0]) :
+                    Guard.IsEqual(ref, 'Exclude') ? S.ExcludeDeferred(parameters[0], parameters[1]) :
+                        Guard.IsEqual(ref, 'Extract') ? S.ExtractDeferred(parameters[0], parameters[1]) :
+                            Guard.IsEqual(ref, 'Index') ? S.IndexDeferred(parameters[0], parameters[1]) :
+                                Guard.IsEqual(ref, 'InstanceType') ? S.InstanceTypeDeferred(parameters[0]) :
+                                    Guard.IsEqual(ref, 'Lowercase') ? S.LowercaseDeferred(parameters[0]) :
+                                        Guard.IsEqual(ref, 'NonNullable') ? S.NonNullableDeferred(parameters[0]) :
+                                            Guard.IsEqual(ref, 'Omit') ? S.OmitDeferred(parameters[0], parameters[1]) :
+                                                Guard.IsEqual(ref, 'Parameters') ? S.ParametersDeferred(parameters[0]) :
+                                                    Guard.IsEqual(ref, 'Partial') ? S.PartialDeferred(parameters[0]) :
+                                                        Guard.IsEqual(ref, 'Pick') ? S.PickDeferred(parameters[0], parameters[1]) :
+                                                            Guard.IsEqual(ref, 'Readonly') ? S.ReadonlyObjectDeferred(parameters[0]) :
+                                                                Guard.IsEqual(ref, 'KeyOf') ? S.KeyOfDeferred(parameters[0]) :
+                                                                    Guard.IsEqual(ref, 'Record') ? T.RecordDeferred(parameters[0], parameters[1]) :
+                                                                        Guard.IsEqual(ref, 'Required') ? S.RequiredDeferred(parameters[0]) :
+                                                                            Guard.IsEqual(ref, 'ReturnType') ? S.ReturnTypeDeferred(parameters[0]) :
+                                                                                Guard.IsEqual(ref, 'Uncapitalize') ? S.UncapitalizeDeferred(parameters[0]) :
+                                                                                    Guard.IsEqual(ref, 'Uppercase') ? S.UppercaseDeferred(parameters[0]) :
+                                                                                        T.CallConstruct(T.Ref(ref), parameters));
     // deno-coverage-ignore-stop
 }
 // ------------------------------------------------------------------

package/build/type/types/_refine.d.mts

@@ -18,8 +18,6 @@ export interface TRefinement<Value extends unknown = unknown> {
 export declare function Refine<Type extends TSchema, Value = Static<Type>>(type: Type, check: TRefineCheckCallback<Value>, error: TRefineErrorCallback<Value>): TRefineAdd<Type>;
 /** Refines a type with an explicit check */
 export declare function Refine<Type extends TSchema, Value = Static<Type>>(type: Type, check: TRefineCheckCallback<Value>): TRefineAdd<Type>;
-/** @deprecated Use the error callback signature to generate error message. This overload will be removed in the next version  */
-export declare function Refine<Type extends TSchema, Value = Static<Type>>(type: Type, check: TRefineCheckCallback<Value>, message: string): TRefineAdd<Type>;
 /** Returns true if the given value is a TRefinement. */
 export declare function IsRefinement(value: unknown): value is TRefinement;
 /** Returns true if the given value is a TRefine. */

package/build/type/types/_refine.mjs

@@ -10,11 +10,10 @@ export function RefineAdd(type, refinement) {
 }
 /** Refines a type with an explicit check */
 export function Refine(...args) {
-    const [type, check, error_or_message] = Arguments.Match(args, {
+    const [type, check, error] = Arguments.Match(args, {
         3: (type, check, error) => [type, check, error],
         2: (type, check) => [type, check, () => 'Refine Error'],
     });
-    const error = Guard.IsString(error_or_message) ? () => error_or_message : error_or_message;
     return RefineAdd(type, { check, error });
 }
 // ------------------------------------------------------------------

package/build/type/types/index.d.mts

@@ -5,8 +5,6 @@ export * from './_readonly.mjs';
 export * from './_refine.mjs';
 export * from './any.mjs';
 export * from './array.mjs';
-export * from './async_iterator.mjs';
-export * from './base.mjs';
 export * from './bigint.mjs';
 export * from './boolean.mjs';
 export * from './call.mjs';
@@ -21,7 +19,6 @@ export * from './dependent.mjs';
 export * from './infer.mjs';
 export * from './integer.mjs';
 export * from './intersect.mjs';
-export * from './iterator.mjs';
 export * from './literal.mjs';
 export * from './never.mjs';
 export * from './null.mjs';
@@ -30,7 +27,6 @@ export * from './unknown.mjs';
 export * from './symbol.mjs';
 export * from './object.mjs';
 export * from './parameter.mjs';
-export * from './promise.mjs';
 export * from './properties.mjs';
 export * from './record.mjs';
 export * from './ref.mjs';

package/build/type/types/index.mjs

@@ -11,8 +11,6 @@ export * from './_refine.mjs';
 // ------------------------------------------------------------------
 export * from './any.mjs';
 export * from './array.mjs';
-export * from './async_iterator.mjs';
-export * from './base.mjs';
 export * from './bigint.mjs';
 export * from './boolean.mjs';
 export * from './call.mjs';
@@ -27,7 +25,6 @@ export * from './dependent.mjs';
 export * from './infer.mjs';
 export * from './integer.mjs';
 export * from './intersect.mjs';
-export * from './iterator.mjs';
 export * from './literal.mjs';
 export * from './never.mjs';
 export * from './null.mjs';
@@ -36,7 +33,6 @@ export * from './unknown.mjs';
 export * from './symbol.mjs';
 export * from './object.mjs';
 export * from './parameter.mjs';
-export * from './promise.mjs';
 export * from './properties.mjs';
 export * from './record.mjs';
 export * from './ref.mjs';