@depup/typebox 1.1.23-depup.0 → 1.3.9-depup.0

package/build/type/engine/indexed/from_object.mjs

@@ -0,0 +1,40 @@
+// deno-fmt-ignore-file
+import { IsNumber } from '../../types/number.mjs';
+import { Never } from '../../types/never.mjs';
+import { PropertyKeys } from '../../types/properties.mjs';
+import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+import { ToIndexableKeys } from '../indexable/to_indexable_keys.mjs';
+import { IntegerKey } from '../../types/record.mjs';
+import { ExpandThis } from '../this/expand_this.mjs';
+function IndexProperty(properties, key) {
+    const selectedType = key in properties ? properties[key] : Never();
+    const result = ExpandThis(properties, selectedType);
+    return result;
+}
+function IndexProperties(properties, keys) {
+    return keys.reduce((result, left) => {
+        return [...result, IndexProperty(properties, left)];
+    }, []);
+}
+function FromIndexer(properties, indexer) {
+    const keys = ToIndexableKeys(indexer);
+    const variants = IndexProperties(properties, keys);
+    const result = EvaluateUnion(variants);
+    return result;
+}
+const NumericKeyPattern = new RegExp(IntegerKey);
+function NumericKeys(keys) {
+    const result = keys.filter(key => NumericKeyPattern.test(key));
+    return result;
+}
+function FromIndexerNumber(properties) {
+    const keys = PropertyKeys(properties);
+    const numericKeys = NumericKeys(keys);
+    const variants = IndexProperties(properties, numericKeys);
+    const result = EvaluateUnion(variants);
+    return result;
+}
+export function FromObject(properties, indexer) {
+    const result = IsNumber(indexer) ? FromIndexerNumber(properties) : FromIndexer(properties, indexer);
+    return result;
+}

package/build/type/engine/indexed/{from-tuple.d.mts → from_tuple.d.mts}

@@ -4,7 +4,7 @@ import { type TNumber } from '../../types/number.mjs';
 import { type TInteger } from '../../types/integer.mjs';
 import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
 import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
-import { type TFormatArrayIndexer } from './array-indexer.mjs';
+import { type TFormatArrayIndexer } from './array_indexer.mjs';
 type TIndexElementsWithIndexer<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer Right extends TSchema] ? TExtends<{}, TLiteral<Left['length']>, Indexer> extends ExtendsResult.TExtendsTrueLike ? TIndexElementsWithIndexer<Left, Indexer, [Right, ...Result]> : TIndexElementsWithIndexer<Left, Indexer, Result> : Result);
 type TFromTupleWithIndexer<Types extends TSchema[], Indexer extends TSchema, ArrayIndexer extends TSchema = TFormatArrayIndexer<Indexer>, Elements extends TSchema[] = TIndexElementsWithIndexer<Types, ArrayIndexer>, Result extends TSchema = TEvaluateUnionFast<Elements>> = Result;
 type TFromTupleWithoutIndexer<Types extends TSchema[], Result extends TSchema = TEvaluateUnionFast<Types>> = Result;

package/build/type/engine/indexed/{from-tuple.mjs → from_tuple.mjs}

@@ -6,7 +6,7 @@ import { IsNumber } from '../../types/number.mjs';
 import { IsInteger } from '../../types/integer.mjs';
 import { EvaluateUnionFast } from '../evaluate/evaluate.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
-import { FormatArrayIndexer } from './array-indexer.mjs';
+import { FormatArrayIndexer } from './array_indexer.mjs';
 function IndexElementsWithIndexer(types, indexer) {
     return types.reduceRight((result, right, index) => {
         const check = Extends({}, Literal(index), indexer);

package/build/type/engine/indexed/from_type.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TFromArray } from './from_array.mjs';
+import { type TFromObject } from './from_object.mjs';
+import { type TFromTuple } from './from_tuple.mjs';
+export type TFromType<Type extends TSchema, Indexer extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<Type, Indexer> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<Properties, Indexer> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Indexer> : TNever);
+export declare function FromType<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer): TFromType<Type, Indexer>;

package/build/type/engine/indexed/from_type.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { IsArray } from '../../types/array.mjs';
+import { Never } from '../../types/never.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+import { FromArray } from './from_array.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromTuple } from './from_tuple.mjs';
+export function FromType(type, indexer) {
+    return (IsArray(type) ? FromArray(type.items, indexer) :
+        IsObject(type) ? FromObject(type.properties, indexer) :
+            IsTuple(type) ? FromTuple(type.items, indexer) :
+                Never());
+}

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

@@ -1,21 +1,16 @@
 import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
-import { type TArray } from '../../types/array.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
+import { type TDependent } from '../../types/dependent.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
-import { type TNever } from '../../types/never.mjs';
 import { type TProperties } from '../../types/properties.mjs';
-import { type TObject } from '../../types/object.mjs';
-import { type TTuple } from '../../types/tuple.mjs';
 import { type TUnion } from '../../types/union.mjs';
-import { type TFromArray } from './from-array.mjs';
-import { type TFromObject } from './from-object.mjs';
-import { type TFromTuple } from './from-tuple.mjs';
-import { type TState, type TInstantiateType, TCanInstantiate } from '../instantiate.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TIndexDeferred } from '../../action/indexed.mjs';
 import { type TCollapseToObject } from '../object/index.mjs';
-type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
-type TIndexAction<Type extends TSchema, Indexer extends TSchema, Normal extends TSchema = TNormalizeType<Type>> = (Normal extends TArray<infer Type extends TSchema> ? TFromArray<Type, Indexer> : Normal extends TObject<infer Properties extends TProperties> ? TFromObject<Properties, Indexer> : Normal extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Indexer> : TNever);
-type TIndexImmediate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, InstantiatedIndexer extends TSchema = TInstantiateType<Context, State, Indexer>> = TIndexAction<InstantiatedType, InstantiatedIndexer>;
-export type TIndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema> = TCanInstantiate<Context, [Type, Indexer]> extends true ? TIndexImmediate<Context, State, Type, Indexer> : TIndexDeferred<Type, Indexer>;
+import { type TFromType } from './from_type.mjs';
+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 TIndexAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<TNormalizeType<Type>, Indexer> : TIndexDeferred<Type, Indexer>> = Result;
+export declare function IndexAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TIndexAction<Type, Indexer>;
+export type TIndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, InstantiatedIndexer extends TSchema = TInstantiateType<Context, State, Indexer>> = TIndexAction<InstantiatedType, InstantiatedIndexer>;
 export declare function IndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema>(context: Context, state: State, type: Type, indexer: Indexer, options: TSchemaOptions): TIndexInstantiate<Context, State, Type, Indexer>;
 export {};

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

@@ -1,37 +1,28 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
-import { IsArray } from '../../types/array.mjs';
 import { IsCyclic } from '../../types/cyclic.mjs';
+import { IsDependent } from '../../types/dependent.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
-import { Never } from '../../types/never.mjs';
-import { IsObject } from '../../types/object.mjs';
-import { IsTuple } from '../../types/tuple.mjs';
 import { IsUnion } from '../../types/union.mjs';
-import { FromArray } from './from-array.mjs';
-import { FromObject } from './from-object.mjs';
-import { FromTuple } from './from-tuple.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { IndexDeferred } from '../../action/indexed.mjs';
 import { CollapseToObject } from '../object/index.mjs';
+import { FromType } from './from_type.mjs';
 function NormalizeType(type) {
-    const result = (IsCyclic(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) :
-        type);
+    const result = (IsCyclic(type) ||
+        IsDependent(type) ||
+        IsIntersect(type) ||
+        IsUnion(type)) ? CollapseToObject(type) : type;
     return result;
 }
-function IndexAction(type, indexer) {
-    const normal = NormalizeType(type);
-    return (IsArray(normal) ? FromArray(normal.items, indexer) :
-        IsObject(normal) ? FromObject(normal.properties, indexer) :
-            IsTuple(normal) ? FromTuple(normal.items, indexer) :
-                Never());
+export function IndexAction(type, indexer, options) {
+    const result = CanInstantiate([type, indexer])
+        ? Memory.Update(FromType(NormalizeType(type), indexer), {}, options)
+        : IndexDeferred(type, indexer, options);
+    return result;
 }
-function IndexImmediate(context, state, type, indexer, options) {
+export function IndexInstantiate(context, state, type, indexer, options) {
     const instantiatedType = InstantiateType(context, state, type);
     const instantiatedIndexer = InstantiateType(context, state, indexer);
-    return Memory.Update(IndexAction(instantiatedType, instantiatedIndexer), {}, options);
-}
-export function IndexInstantiate(context, state, type, indexer, options) {
-    return (CanInstantiate(context, [type, indexer])
-        ? IndexImmediate(context, state, type, indexer, options)
-        : IndexDeferred(type, indexer, options));
+    return IndexAction(instantiatedType, instantiatedIndexer, options);
 }

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TInstanceTypeDeferred } from '../../action/instance_type.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TInstanceTypeOperation<Type extends TSchema> = (Type extends TConstructor ? Type['instanceType'] : TNever);
+export type TInstanceTypeAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TInstanceTypeOperation<Type> : TInstanceTypeDeferred<Type>> = Result;
+export declare function InstanceTypeAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TInstanceTypeAction<Type>;
+export type TInstanceTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TInstanceTypeAction<InstantiatedType>;
+export declare function InstanceTypeInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options?: TSchemaOptions): TInstanceTypeInstantiate<Context, State, Type>;
+export {};

package/build/type/engine/{instance-type → instance_type}/instantiate.mjs

@@ -2,19 +2,20 @@
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsConstructor } from '../../types/constructor.mjs';
 import { Never } from '../../types/never.mjs';
-import { InstanceTypeDeferred } from '../../action/instance-type.mjs';
+import { InstanceTypeDeferred } from '../../action/instance_type.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
-function InstanceTypeAction(type) {
+function InstanceTypeOperation(type) {
     return (IsConstructor(type)
-        ? type.instanceType
+        ? type['instanceType']
         : Never());
 }
-export function InstanceTypeImmediate(context, state, type, options) {
-    const instantiatedType = InstantiateType(context, state, type);
-    return Memory.Update(InstanceTypeAction(instantiatedType), {}, options);
+export function InstanceTypeAction(type, options) {
+    const result = CanInstantiate([type])
+        ? Memory.Update(InstanceTypeOperation(type), {}, options)
+        : InstanceTypeDeferred(type, options);
+    return result;
 }
 export function InstanceTypeInstantiate(context, state, type, options = {}) {
-    return (CanInstantiate(context, [type])
-        ? InstanceTypeImmediate(context, state, type, options)
-        : InstanceTypeDeferred(type, options));
+    const instantiatedType = InstantiateType(context, state, type);
+    return InstanceTypeAction(instantiatedType, options);
 }

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

@@ -1,71 +1,67 @@
-import { type TImmutable } from '../types/_immutable.mjs';
-import { type TOptional, TOptionalAdd, TOptionalRemove } from '../types/_optional.mjs';
-import { type TReadonly, TReadonlyAdd, TReadonlyRemove } from '../types/_readonly.mjs';
+import { type TAddImmutableAction } from './immutable/instantiate_add.mjs';
+import { type TAddReadonlyAction } from './readonly/instantiate_add.mjs';
+import { type TAddOptionalAction } from './optional/instantiate_add.mjs';
 import { type TSchema } from '../types/schema.mjs';
 import { type TArray } from '../types/array.mjs';
-import { type TAsyncIterator } from '../types/async-iterator.mjs';
 import { type TConstructor } from '../types/constructor.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
 import { type TFunction } from '../types/function.mjs';
 import { type TCall } from '../types/call.mjs';
 import { type TIdentifier } from '../types/identifier.mjs';
+import { type TDependent } from '../types/dependent.mjs';
 import { type TIntersect } from '../types/intersect.mjs';
-import { type TIterator } from '../types/iterator.mjs';
 import { type TObject } from '../types/object.mjs';
-import { type TPromise } from '../types/promise.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TRecord } from '../types/record.mjs';
 import { type TTuple } from '../types/tuple.mjs';
 import { type TUnion } from '../types/union.mjs';
 import { type TRef } from '../types/ref.mjs';
 import { type TRest } from '../types/rest.mjs';
-import { type TReadonlyAddAction, type TReadonlyRemoveAction } from '../action/_readonly.mjs';
-import { type TOptionalAddAction, type TOptionalRemoveAction } from '../action/_optional.mjs';
-import { type TAwaitedInstantiate } from './awaited/instantiate.mjs';
+import { type TAddImmutableInstantiate } from './immutable/instantiate_add.mjs';
+import { type TRemoveImmutableInstantiate } from './immutable/instantiate_remove.mjs';
+import { type TAddReadonlyInstantiate } from './readonly/instantiate_add.mjs';
+import { type TRemoveReadonlyInstantiate } from './readonly/instantiate_remove.mjs';
+import { type TAddOptionalInstantiate } from './optional/instantiate_add.mjs';
+import { type TRemoveOptionalInstantiate } from './optional/instantiate_remove.mjs';
+import { type TOptional } from '../types/_optional.mjs';
+import { type TImmutable } from '../types/_immutable.mjs';
+import { type TReadonly } from '../types/_readonly.mjs';
 import { type TCallInstantiate } from './call/instantiate.mjs';
 import { type TCapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { type TConditionalInstantiate } from './conditional/index.mjs';
-import { type TConstructorParametersInstantiate } from './constructor-parameters/instantiate.mjs';
+import { type TConstructorParametersInstantiate } from './constructor_parameters/instantiate.mjs';
 import { type TEvaluateInstantiate } from './evaluate/instantiate.mjs';
 import { type TExcludeInstantiate } from './exclude/instantiate.mjs';
 import { type TExtractInstantiate } from './extract/instantiate.mjs';
 import { type TIndexInstantiate } from './indexed/instantiate.mjs';
-import { type TInstanceTypeInstantiate } from './instance-type/instantiate.mjs';
+import { type TInstanceTypeInstantiate } from './instance_type/instantiate.mjs';
 import { type TInterfaceInstantiate } from './interface/instantiate.mjs';
 import { type TKeyOfInstantiate } from './keyof/instantiate.mjs';
 import { type TLowercaseInstantiate } from './intrinsics/instantiate.mjs';
 import { type TMappedInstantiate } from './mapped/instantiate.mjs';
 import { type TModuleInstantiate } from './module/instantiate.mjs';
-import { type TNonNullableInstantiate } from './non-nullable/instantiate.mjs';
+import { type TNonNullableInstantiate } from './non_nullable/instantiate.mjs';
 import { type TOmitInstantiate } from './omit/instantiate.mjs';
-import { type TOptionsInstantiate } from './options/instantiate.mjs';
 import { type TParametersInstantiate } from './parameters/instantiate.mjs';
 import { type TPartialInstantiate } from './partial/instantiate.mjs';
 import { type TPickInstantiate } from './pick/instantiate.mjs';
-import { type TReadonlyTypeInstantiate } from './readonly-type/instantiate.mjs';
+import { type TReadonlyObjectInstantiate } from './readonly_object/instantiate.mjs';
 import { type TRecordInstantiate } from './record/instantiate.mjs';
 import { type TRefInstantiate } from './ref/instantiate.mjs';
 import { type TRequiredInstantiate } from './required/instantiate.mjs';
-import { type TReturnTypeInstantiate } from './return-type/instantiate.mjs';
-import { type TTemplateLiteralInstantiate } from './template-literal/instantiate.mjs';
+import { type TReturnTypeInstantiate } from './return_type/instantiate.mjs';
+import { type TTemplateLiteralInstantiate } from './template_literal/instantiate.mjs';
 import { type TUncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { type TUppercaseInstantiate } from './intrinsics/instantiate.mjs';
+import { type TWithInstantiate } from './with/instantiate.mjs';
 import { type TRestSpread } from './rest/index.mjs';
-export interface TState {
-    callstack: string[];
+export interface TState<CallStack extends string[] = string[], Visited extends string[] = string[]> {
+    callstack: CallStack;
+    visited: Visited;
 }
-type TCanInstantiateRef<Context extends TProperties, Ref extends string> = (Ref extends keyof Context ? true : false);
-type TCanInstantiateType<Context extends TProperties, Type extends TSchema> = (Type extends TIntersect<infer Types extends TSchema[]> ? TCanInstantiate<Context, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TCanInstantiate<Context, Types> : Type extends TRef<infer Ref extends string> ? TCanInstantiateRef<Context, Ref> : true);
-export type TCanInstantiate<Context extends TProperties, Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCanInstantiateType<Context, Left> extends true ? TCanInstantiate<Context, Right> : false : true;
-export declare function CanInstantiate<Context extends TProperties, Types extends TSchema[]>(context: Context, types: [...Types]): TCanInstantiate<Context, Types>;
-type ModifierAction = 'add' | 'remove' | 'none';
-type TModifierActions<Type extends TSchema, Readonly extends ModifierAction, Optional extends ModifierAction> = (Type extends TReadonlyRemoveAction<infer Type extends TSchema> ? TModifierActions<Type, 'remove', Optional> : Type extends TOptionalRemoveAction<infer Type extends TSchema> ? TModifierActions<Type, Readonly, 'remove'> : Type extends TReadonlyAddAction<infer Type extends TSchema> ? TModifierActions<Type, 'add', Optional> : Type extends TOptionalAddAction<infer Type extends TSchema> ? TModifierActions<Type, Readonly, 'add'> : [
-    Type,
-    Readonly,
-    Optional
-]);
-type TApplyReadonly<Action extends ModifierAction, Type extends TSchema> = (Action extends 'remove' ? TReadonlyRemove<Type> : Action extends 'add' ? TReadonlyAdd<Type> : Type);
-type TApplyOptional<Action extends ModifierAction, Type extends TSchema> = (Action extends 'remove' ? TOptionalRemove<Type> : Action extends 'add' ? TOptionalAdd<Type> : Type);
+export declare function State<CallStack extends string[], Visited extends string[]>(callstack: CallStack, visited: Visited): TState<CallStack, Visited>;
+export type TCanInstantiate<Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TRef ? false : TCanInstantiate<Right> : true;
+export declare function CanInstantiate<Types extends TSchema[]>(types: [...Types]): TCanInstantiate<Types>;
 export type TInstantiateProperties<Context extends TProperties, State extends TState, Properties extends TProperties, Result extends TProperties = {
     [Key in keyof Properties]: TInstantiateType<Context, State, Properties[Key]>;
 }> = Result;
@@ -74,10 +70,26 @@ export type TInstantiateElements<Context extends TProperties, State extends TSta
 export declare function InstantiateElements<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateElements<Context, State, Types>;
 export type TInstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TInstantiateTypes<Context, State, Right, [...Result, TInstantiateType<Context, State, Left>]> : Result);
 export declare function InstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateTypes<Context, State, Types>;
+type TWithModifiers<Type extends TSchema, InstantiatedType extends TSchema, WithOptional extends TSchema = Type extends TOptional ? TAddOptionalAction<InstantiatedType> : InstantiatedType, WithReadonly extends TSchema = Type extends TReadonly ? TAddReadonlyAction<WithOptional> : WithOptional, WithImmutable extends TSchema = Type extends TImmutable ? TAddImmutableAction<WithReadonly> : WithReadonly> = WithImmutable;
 type TInstantiateDeferred<Context extends TProperties, State extends TState, Action extends string, Parameters extends TSchema[]> = ([
     Action,
     Parameters
-] extends ['Awaited', [infer Type extends TSchema]] ? TAwaitedInstantiate<Context, State, Type> : [
+] extends ['AddImmutable', [infer Type extends TSchema]] ? TAddImmutableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveImmutable', [infer Type extends TSchema]] ? TRemoveImmutableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['AddReadonly', [infer Type extends TSchema]] ? TAddReadonlyInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveReadonly', [infer Type extends TSchema]] ? TRemoveReadonlyInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['AddOptional', [infer Type extends TSchema]] ? TAddOptionalInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveOptional', [infer Type extends TSchema]] ? TRemoveOptionalInstantiate<Context, State, Type> : [
     Action,
     Parameters
 ] extends ['Capitalize', [infer Type extends TSchema]] ? TCapitalizeInstantiate<Context, State, Type> : [
@@ -116,7 +128,7 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 ] extends ['Mapped', [infer Name extends TIdentifier, infer Key extends TSchema, infer As extends TSchema, infer Property extends TSchema]] ? TMappedInstantiate<Context, State, Name, Key, As, Property> : [
     Action,
     Parameters
-] extends ['Module', [infer Properties extends TProperties]] ? TModuleInstantiate<Context, State, Properties> : [
+] extends ['Module', [infer Declarations extends TProperties]] ? TModuleInstantiate<Context, State, Declarations> : [
     Action,
     Parameters
 ] extends ['NonNullable', [infer Type extends TSchema]] ? TNonNullableInstantiate<Context, State, Type> : [
@@ -125,9 +137,6 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 ] extends ['Pick', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TPickInstantiate<Context, State, Type, Indexer> : [
     Action,
     Parameters
-] extends ['Options', [infer Type extends TSchema, infer Options extends TSchema]] ? TOptionsInstantiate<Context, State, Type, Options> : [
-    Action,
-    Parameters
 ] extends ['Parameters', [infer Type extends TSchema]] ? TParametersInstantiate<Context, State, Type> : [
     Action,
     Parameters
@@ -137,7 +146,7 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 ] extends ['Omit', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TOmitInstantiate<Context, State, Type, Indexer> : [
     Action,
     Parameters
-] extends ['ReadonlyType', [infer Type extends TSchema]] ? TReadonlyTypeInstantiate<Context, State, Type> : [
+] extends ['ReadonlyObject', [infer Type extends TSchema]] ? TReadonlyObjectInstantiate<Context, State, Type> : [
     Action,
     Parameters
 ] extends ['Record', [infer Key extends TSchema, infer Value extends TSchema]] ? TRecordInstantiate<Context, State, Key, Value> : [
@@ -155,13 +164,15 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 ] extends ['Uncapitalize', [infer Type extends TSchema]] ? TUncapitalizeInstantiate<Context, State, Type> : [
     Action,
     Parameters
-] extends ['Uppercase', [infer Type extends TSchema]] ? TUppercaseInstantiate<Context, State, Type> : TDeferred<Action, Parameters>);
-export type TInstantiateType<Context extends TProperties, State extends TState, Input extends TSchema, Immutable extends boolean = Input extends TImmutable ? true : false, Modifiers extends [TSchema, ModifierAction, ModifierAction] = TModifierActions<Input, Input extends TReadonly<Input> ? 'add' : 'none', Input extends TOptional<Input> ? 'add' : 'none'>, Type extends TSchema = Modifiers[0], Instantiated extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Type, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TInstantiateType<Context, State, Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TInstantiateType<Context, State, Type>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type), WithImmutable extends TSchema = Immutable extends true ? TImmutable<Instantiated> : Instantiated, WithModifiers extends TSchema = TApplyReadonly<Modifiers[1], TApplyOptional<Modifiers[2], WithImmutable>>> = WithModifiers;
-export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, input: Type): TInstantiateType<Context, State, Type>;
+] extends ['Uppercase', [infer Type extends TSchema]] ? TUppercaseInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['With', [infer Type extends TSchema, infer Options extends TSchema]] ? TWithInstantiate<Context, State, Type, Options> : TDeferred<Action, Parameters>);
+type TInstantiateImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Type, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TDependent<TInstantiateType<Context, State, If>, TInstantiateType<Context, State, Then>, TInstantiateType<Context, State, Else>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type), WithModifiers extends TSchema = TWithModifiers<Type, InstantiatedType>> = WithModifiers;
+export type TInstantiateType<Context extends TProperties, State extends TState, Type extends TSchema, Result extends TSchema = Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : TInstantiateImmediate<Context, State, Type>> = Result;
+export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type): TInstantiateImmediate<Context, State, Type>;
 /** Instantiates computed schematics using the given context and type. */
-export type TInstantiate<Context extends TProperties, Type extends TSchema> = (TInstantiateType<Context, {
-    callstack: [];
-}, Type>);
+export type TInstantiate<Context extends TProperties, Type extends TSchema> = (TInstantiateType<Context, TState<[], []>, Type>);
 /** Instantiates computed schematics using the given context and type. */
 export declare function Instantiate<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): TInstantiate<Context, Type>;
 export {};