pareto 0.76.28 → 0.76.30

package/dist/generated/interface/core/resolved.d.ts

@@ -1,100 +1,100 @@
 import * as _pt from 'exupery-core-types';
-export type _T_Derived_Reference<G_Source, T_Type> = T_Type;
-export type _T_Dictionary<G_Source, T_D> = _pt.Dictionary<T_D>;
-export type _T_List<G_Source, T_L> = _pt.Array<T_L>;
-export type _T_Ordered_Dictionary<G_Source, T_D> = {
+export type _T_Derived_Reference<M_Source, T_Type> = T_Type;
+export type _T_Dictionary<M_Source, T_D> = _pt.Dictionary<T_D>;
+export type _T_List<M_Source, T_L> = _pt.Array<T_L>;
+export type _T_Ordered_Dictionary<M_Source, T_D> = {
     readonly 'dictionary': _pt.Dictionary<T_D>;
     readonly 'ordered list': _pt.Array<_pt.Key_Value_Pair<T_D>>;
 };
-export type _T_Reference_To_Circular_Dependent_Sibling<G_Source, T_Dictionary_Entry> = {
+export type _T_Reference_To_Circular_Dependent_Sibling<M_Source, T_Dictionary_Entry> = {
     readonly 'entry': _pt.Computed_Value<T_Dictionary_Entry>;
     readonly 'key': string;
 };
-export type _T_Reference_To_Normal_Dictionary_Entry<G_Source, T_Dictionary_Entry> = {
+export type _T_Reference_To_Normal_Dictionary_Entry<M_Source, T_Dictionary_Entry> = {
     readonly 'entry': T_Dictionary_Entry;
     readonly 'key': string;
 };
-export type _T_Reference_To_Stacked_Dictionary_Entry<G_Source, T_Dictionary_Entry> = {
+export type _T_Reference_To_Stacked_Dictionary_Entry<M_Source, T_Dictionary_Entry> = {
     readonly 'entry': T_Dictionary_Entry;
     readonly 'key': string;
     readonly 'up steps': number;
 };
-export type _T_State_Group<G_Source, T_SG> = T_SG;
-export type Derived_Reference<G_Source, T_Type> = _T_Derived_Reference<G_Source, T_Type>;
-export type Dictionary<G_Source, T_D> = _T_Dictionary<G_Source, T_D>;
-export type List<G_Source, T_L> = _T_List<G_Source, T_L>;
-export type Ordered_Dictionary<G_Source, T_D> = _T_Ordered_Dictionary<G_Source, T_D>;
-export type Reference_To_Circular_Dependent_Sibling<G_Source, T_Dictionary_Entry> = _T_Reference_To_Circular_Dependent_Sibling<G_Source, T_Dictionary_Entry>;
-export type Reference_To_Normal_Dictionary_Entry<G_Source, T_Dictionary_Entry> = _T_Reference_To_Normal_Dictionary_Entry<G_Source, T_Dictionary_Entry>;
-export type Reference_To_Stacked_Dictionary_Entry<G_Source, T_Dictionary_Entry> = _T_Reference_To_Stacked_Dictionary_Entry<G_Source, T_Dictionary_Entry>;
-export type State_Group<G_Source, T_SG> = _T_State_Group<G_Source, T_SG>;
+export type _T_State_Group<M_Source, T_SG> = T_SG;
+export type Derived_Reference<M_Source, T_Type> = _T_Derived_Reference<M_Source, T_Type>;
+export type Dictionary<M_Source, T_D> = _T_Dictionary<M_Source, T_D>;
+export type List<M_Source, T_L> = _T_List<M_Source, T_L>;
+export type Ordered_Dictionary<M_Source, T_D> = _T_Ordered_Dictionary<M_Source, T_D>;
+export type Reference_To_Circular_Dependent_Sibling<M_Source, T_Dictionary_Entry> = _T_Reference_To_Circular_Dependent_Sibling<M_Source, T_Dictionary_Entry>;
+export type Reference_To_Normal_Dictionary_Entry<M_Source, T_Dictionary_Entry> = _T_Reference_To_Normal_Dictionary_Entry<M_Source, T_Dictionary_Entry>;
+export type Reference_To_Stacked_Dictionary_Entry<M_Source, T_Dictionary_Entry> = _T_Reference_To_Stacked_Dictionary_Entry<M_Source, T_Dictionary_Entry>;
+export type State_Group<M_Source, T_SG> = _T_State_Group<M_Source, T_SG>;
 export declare namespace _T_Dictionary {
-    type D<G_Source, T_D> = T_D;
+    type D<M_Source, T_D> = T_D;
 }
 export declare namespace _T_List {
-    type L<G_Source, T_L> = T_L;
+    type L<M_Source, T_L> = T_L;
 }
 export declare namespace _T_Ordered_Dictionary {
     namespace dictionary {
-        type D<G_Source, T_D> = T_D;
+        type D<M_Source, T_D> = T_D;
     }
-    type dictionary<G_Source, T_D> = _pt.Dictionary<T_D>;
+    type dictionary<M_Source, T_D> = _pt.Dictionary<T_D>;
     namespace ordered_list {
         namespace L {
-            type K<G_Source, T_D> = T_D;
+            type K<M_Source, T_D> = T_D;
         }
-        type L<G_Source, T_D> = _pt.Key_Value_Pair<T_D>;
+        type L<M_Source, T_D> = _pt.Key_Value_Pair<T_D>;
     }
-    type ordered_list<G_Source, T_D> = _pt.Array<_pt.Key_Value_Pair<T_D>>;
+    type ordered_list<M_Source, T_D> = _pt.Array<_pt.Key_Value_Pair<T_D>>;
 }
 export declare namespace _T_Reference_To_Circular_Dependent_Sibling {
     namespace entry {
-        type C<G_Source, T_Dictionary_Entry> = T_Dictionary_Entry;
+        type C<M_Source, T_Dictionary_Entry> = T_Dictionary_Entry;
     }
-    type entry<G_Source, T_Dictionary_Entry> = _pt.Computed_Value<T_Dictionary_Entry>;
-    type key<G_Source, T_Dictionary_Entry> = string;
+    type entry<M_Source, T_Dictionary_Entry> = _pt.Computed_Value<T_Dictionary_Entry>;
+    type key<M_Source, T_Dictionary_Entry> = string;
 }
 export declare namespace _T_Reference_To_Normal_Dictionary_Entry {
-    type entry<G_Source, T_Dictionary_Entry> = T_Dictionary_Entry;
-    type key<G_Source, T_Dictionary_Entry> = string;
+    type entry<M_Source, T_Dictionary_Entry> = T_Dictionary_Entry;
+    type key<M_Source, T_Dictionary_Entry> = string;
 }
 export declare namespace _T_Reference_To_Stacked_Dictionary_Entry {
-    type entry<G_Source, T_Dictionary_Entry> = T_Dictionary_Entry;
-    type key<G_Source, T_Dictionary_Entry> = string;
-    type up_steps<G_Source, T_Dictionary_Entry> = number;
+    type entry<M_Source, T_Dictionary_Entry> = T_Dictionary_Entry;
+    type key<M_Source, T_Dictionary_Entry> = string;
+    type up_steps<M_Source, T_Dictionary_Entry> = number;
 }
 export declare namespace Dictionary {
-    type D<G_Source, T_D> = T_D;
+    type D<M_Source, T_D> = T_D;
 }
 export declare namespace List {
-    type L<G_Source, T_L> = T_L;
+    type L<M_Source, T_L> = T_L;
 }
 export declare namespace Ordered_Dictionary {
     namespace dictionary {
-        type D<G_Source, T_D> = T_D;
+        type D<M_Source, T_D> = T_D;
     }
-    type dictionary<G_Source, T_D> = _pt.Dictionary<T_D>;
+    type dictionary<M_Source, T_D> = _pt.Dictionary<T_D>;
     namespace ordered_list {
         namespace L {
-            type K<G_Source, T_D> = T_D;
+            type K<M_Source, T_D> = T_D;
         }
-        type L<G_Source, T_D> = _pt.Key_Value_Pair<T_D>;
+        type L<M_Source, T_D> = _pt.Key_Value_Pair<T_D>;
     }
-    type ordered_list<G_Source, T_D> = _pt.Array<_pt.Key_Value_Pair<T_D>>;
+    type ordered_list<M_Source, T_D> = _pt.Array<_pt.Key_Value_Pair<T_D>>;
 }
 export declare namespace Reference_To_Circular_Dependent_Sibling {
     namespace entry {
-        type C<G_Source, T_Dictionary_Entry> = T_Dictionary_Entry;
+        type C<M_Source, T_Dictionary_Entry> = T_Dictionary_Entry;
     }
-    type entry<G_Source, T_Dictionary_Entry> = _pt.Computed_Value<T_Dictionary_Entry>;
-    type key<G_Source, T_Dictionary_Entry> = string;
+    type entry<M_Source, T_Dictionary_Entry> = _pt.Computed_Value<T_Dictionary_Entry>;
+    type key<M_Source, T_Dictionary_Entry> = string;
 }
 export declare namespace Reference_To_Normal_Dictionary_Entry {
-    type entry<G_Source, T_Dictionary_Entry> = T_Dictionary_Entry;
-    type key<G_Source, T_Dictionary_Entry> = string;
+    type entry<M_Source, T_Dictionary_Entry> = T_Dictionary_Entry;
+    type key<M_Source, T_Dictionary_Entry> = string;
 }
 export declare namespace Reference_To_Stacked_Dictionary_Entry {
-    type entry<G_Source, T_Dictionary_Entry> = T_Dictionary_Entry;
-    type key<G_Source, T_Dictionary_Entry> = string;
-    type up_steps<G_Source, T_Dictionary_Entry> = number;
+    type entry<M_Source, T_Dictionary_Entry> = T_Dictionary_Entry;
+    type key<M_Source, T_Dictionary_Entry> = string;
+    type up_steps<M_Source, T_Dictionary_Entry> = number;
 }

package/dist/generated/interface/core/unconstrained.d.ts

@@ -1,19 +1,19 @@
 import * as _pt from 'exupery-core-types';
-export type _T_Dictionary<G_Source, T_D> = _pt.Dictionary<T_D>;
-export type _T_List<G_Source, T_L> = _pt.Array<T_L>;
-export type _T_State_Group<G_Source, T_SG> = T_SG;
-export type Dictionary<G_Source, T_D> = _T_Dictionary<G_Source, T_D>;
-export type List<G_Source, T_L> = _T_List<G_Source, T_L>;
-export type State_Group<G_Source, T_SG> = _T_State_Group<G_Source, T_SG>;
+export type _T_Dictionary<M_Source, T_D> = _pt.Dictionary<T_D>;
+export type _T_List<M_Source, T_L> = _pt.Array<T_L>;
+export type _T_State_Group<M_Source, T_SG> = T_SG;
+export type Dictionary<M_Source, T_D> = _T_Dictionary<M_Source, T_D>;
+export type List<M_Source, T_L> = _T_List<M_Source, T_L>;
+export type State_Group<M_Source, T_SG> = _T_State_Group<M_Source, T_SG>;
 export declare namespace _T_Dictionary {
-    type D<G_Source, T_D> = T_D;
+    type D<M_Source, T_D> = T_D;
 }
 export declare namespace _T_List {
-    type L<G_Source, T_L> = T_L;
+    type L<M_Source, T_L> = T_L;
 }
 export declare namespace Dictionary {
-    type D<G_Source, T_D> = T_D;
+    type D<M_Source, T_D> = T_D;
 }
 export declare namespace List {
-    type L<G_Source, T_L> = T_L;
+    type L<M_Source, T_L> = T_L;
 }

package/dist/generated/interface/core/unresolved.d.ts

@@ -1,184 +1,181 @@
 import * as _pt from 'exupery-core-types';
-export type _T_Derived_Reference<G_Source, T_Type> = null;
-export type _T_Dictionary<G_Source, T_D> = {
+export type _T_Derived_Reference<M_Source, T_Type> = null;
+export type _T_Dictionary<M_Source, T_D> = {
     readonly 'dictionary': _pt.Dictionary<{
         readonly 'entry': T_D;
-        readonly 'location': G_Source;
+        readonly 'location': M_Source;
     }>;
-    readonly 'location': G_Source;
+    readonly 'location': M_Source;
 };
-export type _T_List<G_Source, T_L> = {
+export type _T_List<M_Source, T_L> = {
     readonly 'list': _pt.Array<{
         readonly 'element': T_L;
-        readonly 'location': G_Source;
+        readonly 'location': M_Source;
     }>;
-    readonly 'location': G_Source;
+    readonly 'location': M_Source;
 };
-export type _T_Ordered_Dictionary<G_Source, T_D> = {
+export type _T_Ordered_Dictionary<M_Source, T_D> = {
     readonly 'dictionary': _pt.Dictionary<{
         readonly 'entry': T_D;
-        readonly 'location': G_Source;
+        readonly 'location': M_Source;
     }>;
-    readonly 'location': G_Source;
+    readonly 'location': M_Source;
 };
-export type _T_Reference_To_Circular_Dependent_Sibling<G_Source, T_Dictionary_Entry> = {
+export type _T_Reference_To_Circular_Dependent_Sibling<M_Source, T_Dictionary_Entry> = {
     readonly 'key': string;
-    readonly 'location': G_Source;
+    readonly 'location': M_Source;
 };
-export type _T_Reference_To_Normal_Dictionary_Entry<G_Source, T_Dictionary_Entry> = {
+export type _T_Reference_To_Normal_Dictionary_Entry<M_Source, T_Dictionary_Entry> = {
     readonly 'key': string;
-    readonly 'location': G_Source;
+    readonly 'location': M_Source;
 };
-export type _T_Reference_To_Stacked_Dictionary_Entry<G_Source, T_Dictionary_Entry> = {
+export type _T_Reference_To_Stacked_Dictionary_Entry<M_Source, T_Dictionary_Entry> = {
     readonly 'key': string;
-    readonly 'location': G_Source;
-    readonly 'up steps': number;
+    readonly 'location': M_Source;
 };
-export type _T_State_Group<G_Source, T_SG> = {
-    readonly 'location': G_Source;
+export type _T_State_Group<M_Source, T_SG> = {
+    readonly 'location': M_Source;
     readonly 'state group': T_SG;
 };
-export type Derived_Reference<G_Source, T_Type> = _T_Derived_Reference<G_Source, T_Type>;
-export type Dictionary<G_Source, T_D> = _T_Dictionary<G_Source, T_D>;
-export type List<G_Source, T_L> = _T_List<G_Source, T_L>;
-export type Ordered_Dictionary<G_Source, T_D> = _T_Ordered_Dictionary<G_Source, T_D>;
-export type Reference_To_Circular_Dependent_Sibling<G_Source, T_Dictionary_Entry> = _T_Reference_To_Circular_Dependent_Sibling<G_Source, T_Dictionary_Entry>;
-export type Reference_To_Normal_Dictionary_Entry<G_Source, T_Dictionary_Entry> = _T_Reference_To_Normal_Dictionary_Entry<G_Source, T_Dictionary_Entry>;
-export type Reference_To_Stacked_Dictionary_Entry<G_Source, T_Dictionary_Entry> = _T_Reference_To_Stacked_Dictionary_Entry<G_Source, T_Dictionary_Entry>;
-export type State_Group<G_Source, T_SG> = _T_State_Group<G_Source, T_SG>;
+export type Derived_Reference<M_Source, T_Type> = _T_Derived_Reference<M_Source, T_Type>;
+export type Dictionary<M_Source, T_D> = _T_Dictionary<M_Source, T_D>;
+export type List<M_Source, T_L> = _T_List<M_Source, T_L>;
+export type Ordered_Dictionary<M_Source, T_D> = _T_Ordered_Dictionary<M_Source, T_D>;
+export type Reference_To_Circular_Dependent_Sibling<M_Source, T_Dictionary_Entry> = _T_Reference_To_Circular_Dependent_Sibling<M_Source, T_Dictionary_Entry>;
+export type Reference_To_Normal_Dictionary_Entry<M_Source, T_Dictionary_Entry> = _T_Reference_To_Normal_Dictionary_Entry<M_Source, T_Dictionary_Entry>;
+export type Reference_To_Stacked_Dictionary_Entry<M_Source, T_Dictionary_Entry> = _T_Reference_To_Stacked_Dictionary_Entry<M_Source, T_Dictionary_Entry>;
+export type State_Group<M_Source, T_SG> = _T_State_Group<M_Source, T_SG>;
 export declare namespace _T_Dictionary {
     namespace dictionary {
         namespace D {
-            type entry<G_Source, T_D> = T_D;
-            type location<G_Source, T_D> = G_Source;
+            type entry<M_Source, T_D> = T_D;
+            type location<M_Source, T_D> = M_Source;
         }
-        type D<G_Source, T_D> = {
+        type D<M_Source, T_D> = {
             readonly 'entry': T_D;
-            readonly 'location': G_Source;
+            readonly 'location': M_Source;
         };
     }
-    type dictionary<G_Source, T_D> = _pt.Dictionary<{
+    type dictionary<M_Source, T_D> = _pt.Dictionary<{
         readonly 'entry': T_D;
-        readonly 'location': G_Source;
+        readonly 'location': M_Source;
     }>;
-    type location<G_Source, T_D> = G_Source;
+    type location<M_Source, T_D> = M_Source;
 }
 export declare namespace _T_List {
     namespace list {
         namespace L {
-            type element<G_Source, T_L> = T_L;
-            type location<G_Source, T_L> = G_Source;
+            type element<M_Source, T_L> = T_L;
+            type location<M_Source, T_L> = M_Source;
         }
-        type L<G_Source, T_L> = {
+        type L<M_Source, T_L> = {
             readonly 'element': T_L;
-            readonly 'location': G_Source;
+            readonly 'location': M_Source;
         };
     }
-    type list<G_Source, T_L> = _pt.Array<{
+    type list<M_Source, T_L> = _pt.Array<{
         readonly 'element': T_L;
-        readonly 'location': G_Source;
+        readonly 'location': M_Source;
     }>;
-    type location<G_Source, T_L> = G_Source;
+    type location<M_Source, T_L> = M_Source;
 }
 export declare namespace _T_Ordered_Dictionary {
     namespace dictionary {
         namespace D {
-            type entry<G_Source, T_D> = T_D;
-            type location<G_Source, T_D> = G_Source;
+            type entry<M_Source, T_D> = T_D;
+            type location<M_Source, T_D> = M_Source;
         }
-        type D<G_Source, T_D> = {
+        type D<M_Source, T_D> = {
             readonly 'entry': T_D;
-            readonly 'location': G_Source;
+            readonly 'location': M_Source;
         };
     }
-    type dictionary<G_Source, T_D> = _pt.Dictionary<{
+    type dictionary<M_Source, T_D> = _pt.Dictionary<{
         readonly 'entry': T_D;
-        readonly 'location': G_Source;
+        readonly 'location': M_Source;
     }>;
-    type location<G_Source, T_D> = G_Source;
+    type location<M_Source, T_D> = M_Source;
 }
 export declare namespace _T_Reference_To_Circular_Dependent_Sibling {
-    type key<G_Source, T_Dictionary_Entry> = string;
-    type location<G_Source, T_Dictionary_Entry> = G_Source;
+    type key<M_Source, T_Dictionary_Entry> = string;
+    type location<M_Source, T_Dictionary_Entry> = M_Source;
 }
 export declare namespace _T_Reference_To_Normal_Dictionary_Entry {
-    type key<G_Source, T_Dictionary_Entry> = string;
-    type location<G_Source, T_Dictionary_Entry> = G_Source;
+    type key<M_Source, T_Dictionary_Entry> = string;
+    type location<M_Source, T_Dictionary_Entry> = M_Source;
 }
 export declare namespace _T_Reference_To_Stacked_Dictionary_Entry {
-    type key<G_Source, T_Dictionary_Entry> = string;
-    type location<G_Source, T_Dictionary_Entry> = G_Source;
-    type up_steps<G_Source, T_Dictionary_Entry> = number;
+    type key<M_Source, T_Dictionary_Entry> = string;
+    type location<M_Source, T_Dictionary_Entry> = M_Source;
 }
 export declare namespace _T_State_Group {
-    type location<G_Source, T_SG> = G_Source;
-    type state_group<G_Source, T_SG> = T_SG;
+    type location<M_Source, T_SG> = M_Source;
+    type state_group<M_Source, T_SG> = T_SG;
 }
 export declare namespace Dictionary {
     namespace dictionary {
         namespace D {
-            type entry<G_Source, T_D> = T_D;
-            type location<G_Source, T_D> = G_Source;
+            type entry<M_Source, T_D> = T_D;
+            type location<M_Source, T_D> = M_Source;
         }
-        type D<G_Source, T_D> = {
+        type D<M_Source, T_D> = {
             readonly 'entry': T_D;
-            readonly 'location': G_Source;
+            readonly 'location': M_Source;
         };
     }
-    type dictionary<G_Source, T_D> = _pt.Dictionary<{
+    type dictionary<M_Source, T_D> = _pt.Dictionary<{
         readonly 'entry': T_D;
-        readonly 'location': G_Source;
+        readonly 'location': M_Source;
     }>;
-    type location<G_Source, T_D> = G_Source;
+    type location<M_Source, T_D> = M_Source;
 }
 export declare namespace List {
     namespace list {
         namespace L {
-            type element<G_Source, T_L> = T_L;
-            type location<G_Source, T_L> = G_Source;
+            type element<M_Source, T_L> = T_L;
+            type location<M_Source, T_L> = M_Source;
         }
-        type L<G_Source, T_L> = {
+        type L<M_Source, T_L> = {
             readonly 'element': T_L;
-            readonly 'location': G_Source;
+            readonly 'location': M_Source;
         };
     }
-    type list<G_Source, T_L> = _pt.Array<{
+    type list<M_Source, T_L> = _pt.Array<{
         readonly 'element': T_L;
-        readonly 'location': G_Source;
+        readonly 'location': M_Source;
     }>;
-    type location<G_Source, T_L> = G_Source;
+    type location<M_Source, T_L> = M_Source;
 }
 export declare namespace Ordered_Dictionary {
     namespace dictionary {
         namespace D {
-            type entry<G_Source, T_D> = T_D;
-            type location<G_Source, T_D> = G_Source;
+            type entry<M_Source, T_D> = T_D;
+            type location<M_Source, T_D> = M_Source;
         }
-        type D<G_Source, T_D> = {
+        type D<M_Source, T_D> = {
             readonly 'entry': T_D;
-            readonly 'location': G_Source;
+            readonly 'location': M_Source;
         };
     }
-    type dictionary<G_Source, T_D> = _pt.Dictionary<{
+    type dictionary<M_Source, T_D> = _pt.Dictionary<{
         readonly 'entry': T_D;
-        readonly 'location': G_Source;
+        readonly 'location': M_Source;
     }>;
-    type location<G_Source, T_D> = G_Source;
+    type location<M_Source, T_D> = M_Source;
 }
 export declare namespace Reference_To_Circular_Dependent_Sibling {
-    type key<G_Source, T_Dictionary_Entry> = string;
-    type location<G_Source, T_Dictionary_Entry> = G_Source;
+    type key<M_Source, T_Dictionary_Entry> = string;
+    type location<M_Source, T_Dictionary_Entry> = M_Source;
 }
 export declare namespace Reference_To_Normal_Dictionary_Entry {
-    type key<G_Source, T_Dictionary_Entry> = string;
-    type location<G_Source, T_Dictionary_Entry> = G_Source;
+    type key<M_Source, T_Dictionary_Entry> = string;
+    type location<M_Source, T_Dictionary_Entry> = M_Source;
 }
 export declare namespace Reference_To_Stacked_Dictionary_Entry {
-    type key<G_Source, T_Dictionary_Entry> = string;
-    type location<G_Source, T_Dictionary_Entry> = G_Source;
-    type up_steps<G_Source, T_Dictionary_Entry> = number;
+    type key<M_Source, T_Dictionary_Entry> = string;
+    type location<M_Source, T_Dictionary_Entry> = M_Source;
 }
 export declare namespace State_Group {
-    type location<G_Source, T_SG> = G_Source;
-    type state_group<G_Source, T_SG> = T_SG;
+    type location<M_Source, T_SG> = M_Source;
+    type state_group<M_Source, T_SG> = T_SG;
 }

package/dist/generated/interface/schemas/module/{resolve.d.ts → data_types/resolve.d.ts}

@@ -1,127 +1,127 @@
-import * as _i_resolve from "../../core/resolve";
+import * as _i_resolve from "../../../core/resolve";
 import * as _i_resolved from "./resolved";
 import * as _i_unresolved from "./unresolved";
-export type _T_Module<G_Source> = ($$_: _i_unresolved._T_Module<G_Source>, $$_p: {
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<G_Source>;
+export type _T_Module = <F_Source>($$_: _i_unresolved._T_Module<F_Source>, $$_p: {
+    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
     readonly 'parameters': {
         readonly 'lookups': null;
         readonly 'values': null;
     };
 }) => _i_resolved._T_Module;
-export type _T_Operations<G_Source> = ($$_: _i_unresolved._T_Operations<G_Source>, $$_p: {
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<G_Source>;
+export type _T_Operations = <F_Source>($$_: _i_unresolved._T_Operations<F_Source>, $$_p: {
+    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
     readonly 'parameters': {
         readonly 'lookups': null;
         readonly 'values': null;
     };
 }) => _i_resolved._T_Operations;
-export type Module<G_Source> = _T_Module<G_Source>;
-export type Operations<G_Source> = _T_Operations<G_Source>;
+export type Module = _T_Module;
+export type Operations = _T_Operations;
 export declare namespace _T_Module {
     namespace CONTEXT {
-        type Source<G_Source> = G_Source;
+        type Source<F_Source> = F_Source;
     }
-    type CONTEXT<G_Source> = _i_unresolved._T_Module<G_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Module<F_Source>;
     namespace PARAMS {
         namespace location_2_string {
-            type Source<G_Source> = G_Source;
+            type Source<F_Source> = F_Source;
         }
-        type location_2_string<G_Source> = _i_resolve._T_Location_2_String<G_Source>;
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
             namespace lookups {
             }
-            type lookups<G_Source> = null;
+            type lookups<F_Source> = null;
             namespace values {
             }
-            type values<G_Source> = null;
+            type values<F_Source> = null;
         }
-        type parameters<G_Source> = {
+        type parameters<F_Source> = {
             readonly 'lookups': null;
             readonly 'values': null;
         };
     }
     namespace RESULT {
     }
-    type RESULT<G_Source> = _i_resolved._T_Module;
+    type RESULT<F_Source> = _i_resolved._T_Module;
 }
 export declare namespace _T_Operations {
     namespace CONTEXT {
-        type Source<G_Source> = G_Source;
+        type Source<F_Source> = F_Source;
     }
-    type CONTEXT<G_Source> = _i_unresolved._T_Operations<G_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Operations<F_Source>;
     namespace PARAMS {
         namespace location_2_string {
-            type Source<G_Source> = G_Source;
+            type Source<F_Source> = F_Source;
         }
-        type location_2_string<G_Source> = _i_resolve._T_Location_2_String<G_Source>;
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
             namespace lookups {
             }
-            type lookups<G_Source> = null;
+            type lookups<F_Source> = null;
             namespace values {
             }
-            type values<G_Source> = null;
+            type values<F_Source> = null;
         }
-        type parameters<G_Source> = {
+        type parameters<F_Source> = {
             readonly 'lookups': null;
             readonly 'values': null;
         };
     }
     namespace RESULT {
     }
-    type RESULT<G_Source> = _i_resolved._T_Operations;
+    type RESULT<F_Source> = _i_resolved._T_Operations;
 }
 export declare namespace Module {
     namespace CONTEXT {
-        type Source<G_Source> = G_Source;
+        type Source<F_Source> = F_Source;
     }
-    type CONTEXT<G_Source> = _i_unresolved._T_Module<G_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Module<F_Source>;
     namespace PARAMS {
         namespace location_2_string {
-            type Source<G_Source> = G_Source;
+            type Source<F_Source> = F_Source;
         }
-        type location_2_string<G_Source> = _i_resolve._T_Location_2_String<G_Source>;
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
             namespace lookups {
             }
-            type lookups<G_Source> = null;
+            type lookups<F_Source> = null;
             namespace values {
             }
-            type values<G_Source> = null;
+            type values<F_Source> = null;
         }
-        type parameters<G_Source> = {
+        type parameters<F_Source> = {
             readonly 'lookups': null;
             readonly 'values': null;
         };
     }
     namespace RESULT {
     }
-    type RESULT<G_Source> = _i_resolved._T_Module;
+    type RESULT<F_Source> = _i_resolved._T_Module;
 }
 export declare namespace Operations {
     namespace CONTEXT {
-        type Source<G_Source> = G_Source;
+        type Source<F_Source> = F_Source;
     }
-    type CONTEXT<G_Source> = _i_unresolved._T_Operations<G_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Operations<F_Source>;
     namespace PARAMS {
         namespace location_2_string {
-            type Source<G_Source> = G_Source;
+            type Source<F_Source> = F_Source;
         }
-        type location_2_string<G_Source> = _i_resolve._T_Location_2_String<G_Source>;
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
             namespace lookups {
             }
-            type lookups<G_Source> = null;
+            type lookups<F_Source> = null;
             namespace values {
             }
-            type values<G_Source> = null;
+            type values<F_Source> = null;
         }
-        type parameters<G_Source> = {
+        type parameters<F_Source> = {
             readonly 'lookups': null;
             readonly 'values': null;
         };
     }
     namespace RESULT {
     }
-    type RESULT<G_Source> = _i_resolved._T_Operations;
+    type RESULT<F_Source> = _i_resolved._T_Operations;
 }

package/dist/generated/interface/schemas/{schema → module/data_types}/resolve.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb2x2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9nZW5lcmF0ZWQvaW50ZXJmYWNlL3NjaGVtYXMvc2NoZW1hL3Jlc29sdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb2x2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9nZW5lcmF0ZWQvaW50ZXJmYWNlL3NjaGVtYXMvbW9kdWxlL2RhdGFfdHlwZXMvcmVzb2x2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=