astn 0.113.21 → 0.113.23

package/dist/interface/generated/pareto/schemas/astn_schema/data_types/resolve.d.ts

@@ -1,141 +1,209 @@
-import * as _et from 'pareto-core-interface';
-import * as _i_resolve from 'pareto-core-internals/dist/algorithm_types/refiner/resolve';
+import * as _pi from 'pareto-core-interface';
+import * as _i_resolve from "pareto-core-internals/dist/algorithm_types/refiner/resolve";
 import * as _i_resolved from "./source";
 import * as _i_unresolved from "./target";
-export type _T_Dictionary = <F_Source>($$_: _i_unresolved._T_Dictionary<F_Source>, $$_p: {
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
+export type _T_Text_Type = <F_Source>($$_: _i_unresolved._T_Text_Type<F_Source>, $$_p: {
     readonly 'parameters': {
-        readonly 'lookups': {
-            readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-            readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-        };
-        readonly 'values': {
-            readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-            readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-        };
+        readonly 'values': null;
+        readonly 'lookups': null;
     };
-}) => _i_resolved._T_Dictionary;
-export type _T_Globals = <F_Source>($$_: _i_unresolved._T_Globals<F_Source>, $$_p: {
     readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
+}) => _i_resolved._T_Text_Type;
+export type _T_Globals = <F_Source>($$_: _i_unresolved._T_Globals<F_Source>, $$_p: {
     readonly 'parameters': {
-        readonly 'lookups': null;
         readonly 'values': null;
+        readonly 'lookups': null;
     };
+    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
 }) => _i_resolved._T_Globals;
 export type _T_Group = <F_Source>($$_: _i_unresolved._T_Group<F_Source>, $$_p: {
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
     readonly 'parameters': {
+        readonly 'values': {
+            readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+            readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+        };
         readonly 'lookups': {
             readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
             readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
         };
-        readonly 'values': {
-            readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-            readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-        };
     };
-}) => _i_resolved._T_Group;
-export type _T_Imports = <F_Source>($$_: _i_unresolved._T_Imports<F_Source>, $$_p: {
     readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
+}) => _i_resolved._T_Group;
+export type _T_Dictionary = <F_Source>($$_: _i_unresolved._T_Dictionary<F_Source>, $$_p: {
     readonly 'parameters': {
+        readonly 'values': {
+            readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+            readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+        };
         readonly 'lookups': {
-            readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
         };
-        readonly 'values': null;
     };
-}) => _i_resolved._T_Imports;
-export type _T_Schema = <F_Source>($$_: _i_unresolved._T_Schema<F_Source>, $$_p: {
     readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
+}) => _i_resolved._T_Dictionary;
+export type _T_Type_Node = <F_Source>($$_: _i_unresolved._T_Type_Node<F_Source>, $$_p: {
     readonly 'parameters': {
+        readonly 'values': {
+            readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+            readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+        };
         readonly 'lookups': {
-            readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
         };
-        readonly 'values': null;
     };
-}) => _i_resolved._T_Schema;
-export type _T_Schema_Tree = <F_Source>($$_: _i_unresolved._T_Schema_Tree<F_Source>, $$_p: {
     readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
+}) => _i_resolved._T_Type_Node;
+export type _T_Type = <F_Source>($$_: _i_unresolved._T_Type<F_Source>, $$_p: {
     readonly 'parameters': {
+        readonly 'values': {
+            readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+            readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+        };
         readonly 'lookups': {
-            readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
         };
-        readonly 'values': null;
     };
-}) => _i_resolved._T_Schema_Tree;
-export type _T_Schemas = <F_Source>($$_: _i_unresolved._T_Schemas<F_Source>, $$_p: {
     readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
+}) => _i_resolved._T_Type;
+export type _T_Schemas = <F_Source>($$_: _i_unresolved._T_Schemas<F_Source>, $$_p: {
     readonly 'parameters': {
+        readonly 'values': null;
         readonly 'lookups': {
             readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
         };
-        readonly 'values': null;
     };
-}) => _i_resolved._T_Schemas;
-export type _T_Text_Type = <F_Source>($$_: _i_unresolved._T_Text_Type<F_Source>, $$_p: {
     readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
+}) => _i_resolved._T_Schemas;
+export type _T_Schema_Tree = <F_Source>($$_: _i_unresolved._T_Schema_Tree<F_Source>, $$_p: {
     readonly 'parameters': {
-        readonly 'lookups': null;
         readonly 'values': null;
+        readonly 'lookups': {
+            readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+        };
     };
-}) => _i_resolved._T_Text_Type;
-export type _T_Type = <F_Source>($$_: _i_unresolved._T_Type<F_Source>, $$_p: {
     readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
+}) => _i_resolved._T_Schema_Tree;
+export type _T_Schema = <F_Source>($$_: _i_unresolved._T_Schema<F_Source>, $$_p: {
     readonly 'parameters': {
+        readonly 'values': null;
         readonly 'lookups': {
-            readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-            readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-        };
-        readonly 'values': {
-            readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-            readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
+            readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
         };
     };
-}) => _i_resolved._T_Type;
-export type _T_Type_Node = <F_Source>($$_: _i_unresolved._T_Type_Node<F_Source>, $$_p: {
     readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
+}) => _i_resolved._T_Schema;
+export type _T_Imports = <F_Source>($$_: _i_unresolved._T_Imports<F_Source>, $$_p: {
     readonly 'parameters': {
+        readonly 'values': null;
         readonly 'lookups': {
-            readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-            readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-        };
-        readonly 'values': {
-            readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-            readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
+            readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
         };
     };
-}) => _i_resolved._T_Type_Node;
-export type _T_Types = <F_Source>($$_: _i_unresolved._T_Types<F_Source>, $$_p: {
     readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
+}) => _i_resolved._T_Imports;
+export type _T_Types = <F_Source>($$_: _i_unresolved._T_Types<F_Source>, $$_p: {
     readonly 'parameters': {
-        readonly 'lookups': null;
         readonly 'values': {
-            readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-            readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
+            readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+            readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
         };
+        readonly 'lookups': null;
     };
+    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
 }) => _i_resolved._T_Types;
-export type Dictionary = _T_Dictionary;
+export type Text_Type = _T_Text_Type;
 export type Globals = _T_Globals;
 export type Group = _T_Group;
-export type Imports = _T_Imports;
-export type Schema = _T_Schema;
-export type Schema_Tree = _T_Schema_Tree;
-export type Schemas = _T_Schemas;
-export type Text_Type = _T_Text_Type;
-export type Type = _T_Type;
+export type Dictionary = _T_Dictionary;
 export type Type_Node = _T_Type_Node;
+export type Type = _T_Type;
+export type Schemas = _T_Schemas;
+export type Schema_Tree = _T_Schema_Tree;
+export type Schema = _T_Schema;
+export type Imports = _T_Imports;
 export type Types = _T_Types;
-export declare namespace _T_Dictionary {
+export declare namespace _T_Text_Type {
     namespace CONTEXT {
         type Source<F_Source> = F_Source;
     }
-    type CONTEXT<F_Source> = _i_unresolved._T_Dictionary<F_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Text_Type<F_Source>;
     namespace PARAMS {
+        namespace parameters {
+            namespace values {
+            }
+            type values<F_Source> = null;
+            namespace lookups {
+            }
+            type lookups<F_Source> = null;
+        }
+        type parameters<F_Source> = {
+            readonly 'values': null;
+            readonly 'lookups': null;
+        };
         namespace location_2_string {
             type Source<F_Source> = F_Source;
         }
         type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
+    }
+    namespace RESULT {
+    }
+    type RESULT<F_Source> = _i_resolved._T_Text_Type;
+}
+export declare namespace _T_Globals {
+    namespace CONTEXT {
+        type Source<F_Source> = F_Source;
+    }
+    type CONTEXT<F_Source> = _i_unresolved._T_Globals<F_Source>;
+    namespace PARAMS {
         namespace parameters {
+            namespace values {
+            }
+            type values<F_Source> = null;
+            namespace lookups {
+            }
+            type lookups<F_Source> = null;
+        }
+        type parameters<F_Source> = {
+            readonly 'values': null;
+            readonly 'lookups': null;
+        };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
+    }
+    namespace RESULT {
+    }
+    type RESULT<F_Source> = _i_resolved._T_Globals;
+}
+export declare namespace _T_Group {
+    namespace CONTEXT {
+        type Source<F_Source> = F_Source;
+    }
+    type CONTEXT<F_Source> = _i_unresolved._T_Group<F_Source>;
+    namespace PARAMS {
+        namespace parameters {
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Globals;
+                }
+                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
             namespace lookups {
                 namespace noncircular_sibling_types {
                     namespace T {
@@ -154,78 +222,114 @@ export declare namespace _T_Dictionary {
                 readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
                 readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
+        }
+        type parameters<F_Source> = {
+            readonly 'values': {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
+            readonly 'lookups': {
+                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+        };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
+    }
+    namespace RESULT {
+    }
+    type RESULT<F_Source> = _i_resolved._T_Group;
+}
+export declare namespace _T_Dictionary {
+    namespace CONTEXT {
+        type Source<F_Source> = F_Source;
+    }
+    type CONTEXT<F_Source> = _i_unresolved._T_Dictionary<F_Source>;
+    namespace PARAMS {
+        namespace parameters {
             namespace values {
                 namespace globals {
                     namespace O {
                     }
                     type O<F_Source> = _i_resolved._T_Globals;
                 }
-                type globals<F_Source> = _et.Optional_Value<_i_resolved._T_Globals>;
+                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
                 namespace imports {
                     namespace O {
                     }
                     type O<F_Source> = _i_resolved._T_Imports;
                 }
-                type imports<F_Source> = _et.Optional_Value<_i_resolved._T_Imports>;
+                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
             }
             type values<F_Source> = {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
+            namespace lookups {
+                namespace noncircular_sibling_types {
+                    namespace T {
+                    }
+                    type T<F_Source> = _i_resolved._T_Types.D;
+                }
+                type noncircular_sibling_types<F_Source> = _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                namespace possibly_circular_dependent_sibling_types {
+                    namespace T {
+                    }
+                    type T<F_Source> = _i_resolved._T_Types.D;
+                }
+                type possibly_circular_dependent_sibling_types<F_Source> = _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<F_Source> = {
+                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
         }
         type parameters<F_Source> = {
+            readonly 'values': {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
             readonly 'lookups': {
                 readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
                 readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
-            readonly 'values': {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-            };
         };
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Dictionary;
-}
-export declare namespace _T_Globals {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Globals<F_Source>;
-    namespace PARAMS {
         namespace location_2_string {
             type Source<F_Source> = F_Source;
         }
         type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-        namespace parameters {
-            namespace lookups {
-            }
-            type lookups<F_Source> = null;
-            namespace values {
-            }
-            type values<F_Source> = null;
-        }
-        type parameters<F_Source> = {
-            readonly 'lookups': null;
-            readonly 'values': null;
-        };
     }
     namespace RESULT {
     }
-    type RESULT<F_Source> = _i_resolved._T_Globals;
+    type RESULT<F_Source> = _i_resolved._T_Dictionary;
 }
-export declare namespace _T_Group {
+export declare namespace _T_Type_Node {
     namespace CONTEXT {
         type Source<F_Source> = F_Source;
     }
-    type CONTEXT<F_Source> = _i_unresolved._T_Group<F_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Type_Node<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Globals;
+                }
+                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
             namespace lookups {
                 namespace noncircular_sibling_types {
                     namespace T {
@@ -244,51 +348,136 @@ export declare namespace _T_Group {
                 readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
                 readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
+        }
+        type parameters<F_Source> = {
+            readonly 'values': {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
+            readonly 'lookups': {
+                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+        };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
+    }
+    namespace RESULT {
+    }
+    type RESULT<F_Source> = _i_resolved._T_Type_Node;
+}
+export declare namespace _T_Type {
+    namespace CONTEXT {
+        type Source<F_Source> = F_Source;
+    }
+    type CONTEXT<F_Source> = _i_unresolved._T_Type<F_Source>;
+    namespace PARAMS {
+        namespace parameters {
             namespace values {
                 namespace globals {
                     namespace O {
                     }
                     type O<F_Source> = _i_resolved._T_Globals;
                 }
-                type globals<F_Source> = _et.Optional_Value<_i_resolved._T_Globals>;
+                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
                 namespace imports {
                     namespace O {
                     }
                     type O<F_Source> = _i_resolved._T_Imports;
                 }
-                type imports<F_Source> = _et.Optional_Value<_i_resolved._T_Imports>;
+                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
             }
             type values<F_Source> = {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
+            namespace lookups {
+                namespace noncircular_sibling_types {
+                    namespace T {
+                    }
+                    type T<F_Source> = _i_resolved._T_Types.D;
+                }
+                type noncircular_sibling_types<F_Source> = _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                namespace possibly_circular_dependent_sibling_types {
+                    namespace T {
+                    }
+                    type T<F_Source> = _i_resolved._T_Types.D;
+                }
+                type possibly_circular_dependent_sibling_types<F_Source> = _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<F_Source> = {
+                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
         }
         type parameters<F_Source> = {
+            readonly 'values': {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
             readonly 'lookups': {
                 readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
                 readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
-            readonly 'values': {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-            };
         };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
     }
     namespace RESULT {
     }
-    type RESULT<F_Source> = _i_resolved._T_Group;
+    type RESULT<F_Source> = _i_resolved._T_Type;
 }
-export declare namespace _T_Imports {
+export declare namespace _T_Schemas {
     namespace CONTEXT {
         type Source<F_Source> = F_Source;
     }
-    type CONTEXT<F_Source> = _i_unresolved._T_Imports<F_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Schemas<F_Source>;
     namespace PARAMS {
+        namespace parameters {
+            namespace values {
+            }
+            type values<F_Source> = null;
+            namespace lookups {
+                namespace sibling_schemas {
+                    namespace T {
+                    }
+                    type T<F_Source> = _i_resolved._T_Schemas.D;
+                }
+                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            }
+            type lookups<F_Source> = {
+                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+        }
+        type parameters<F_Source> = {
+            readonly 'values': null;
+            readonly 'lookups': {
+                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+        };
         namespace location_2_string {
             type Source<F_Source> = F_Source;
         }
         type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
+    }
+    namespace RESULT {
+    }
+    type RESULT<F_Source> = _i_resolved._T_Schemas;
+}
+export declare namespace _T_Schema_Tree {
+    namespace CONTEXT {
+        type Source<F_Source> = F_Source;
+    }
+    type CONTEXT<F_Source> = _i_unresolved._T_Schema_Tree<F_Source>;
+    namespace PARAMS {
         namespace parameters {
+            namespace values {
+            }
+            type values<F_Source> = null;
             namespace lookups {
                 namespace sibling_schemas {
                     namespace T {
@@ -300,20 +489,21 @@ export declare namespace _T_Imports {
             type lookups<F_Source> = {
                 readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
             };
-            namespace values {
-            }
-            type values<F_Source> = null;
         }
         type parameters<F_Source> = {
+            readonly 'values': null;
             readonly 'lookups': {
                 readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
             };
-            readonly 'values': null;
         };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
     }
     namespace RESULT {
     }
-    type RESULT<F_Source> = _i_resolved._T_Imports;
+    type RESULT<F_Source> = _i_resolved._T_Schema_Tree;
 }
 export declare namespace _T_Schema {
     namespace CONTEXT {
@@ -321,11 +511,10 @@ export declare namespace _T_Schema {
     }
     type CONTEXT<F_Source> = _i_unresolved._T_Schema<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
+            namespace values {
+            }
+            type values<F_Source> = null;
             namespace lookups {
                 namespace sibling_schemas {
                     namespace T {
@@ -337,133 +526,183 @@ export declare namespace _T_Schema {
             type lookups<F_Source> = {
                 readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
             };
-            namespace values {
-            }
-            type values<F_Source> = null;
         }
         type parameters<F_Source> = {
+            readonly 'values': null;
             readonly 'lookups': {
                 readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
             };
-            readonly 'values': null;
         };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
     }
     namespace RESULT {
     }
     type RESULT<F_Source> = _i_resolved._T_Schema;
 }
-export declare namespace _T_Schema_Tree {
+export declare namespace _T_Imports {
     namespace CONTEXT {
         type Source<F_Source> = F_Source;
     }
-    type CONTEXT<F_Source> = _i_unresolved._T_Schema_Tree<F_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Imports<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
+            namespace values {
+            }
+            type values<F_Source> = null;
             namespace lookups {
                 namespace sibling_schemas {
                     namespace T {
                     }
                     type T<F_Source> = _i_resolved._T_Schemas.D;
                 }
-                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            }
+            type lookups<F_Source> = {
+                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+        }
+        type parameters<F_Source> = {
+            readonly 'values': null;
+            readonly 'lookups': {
+                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+        };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
+    }
+    namespace RESULT {
+    }
+    type RESULT<F_Source> = _i_resolved._T_Imports;
+}
+export declare namespace _T_Types {
+    namespace CONTEXT {
+        type Source<F_Source> = F_Source;
+    }
+    type CONTEXT<F_Source> = _i_unresolved._T_Types<F_Source>;
+    namespace PARAMS {
+        namespace parameters {
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Globals;
+                }
+                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
             }
-            type lookups<F_Source> = {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            type values<F_Source> = {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
             };
-            namespace values {
+            namespace lookups {
             }
-            type values<F_Source> = null;
+            type lookups<F_Source> = null;
         }
         type parameters<F_Source> = {
-            readonly 'lookups': {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            readonly 'values': {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
             };
-            readonly 'values': null;
+            readonly 'lookups': null;
         };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
     }
     namespace RESULT {
     }
-    type RESULT<F_Source> = _i_resolved._T_Schema_Tree;
+    type RESULT<F_Source> = _i_resolved._T_Types;
 }
-export declare namespace _T_Schemas {
+export declare namespace Text_Type {
     namespace CONTEXT {
         type Source<F_Source> = F_Source;
     }
-    type CONTEXT<F_Source> = _i_unresolved._T_Schemas<F_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Text_Type<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
-            namespace lookups {
-                namespace sibling_schemas {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Schemas.D;
-                }
-                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
             namespace values {
             }
             type values<F_Source> = null;
+            namespace lookups {
+            }
+            type lookups<F_Source> = null;
         }
         type parameters<F_Source> = {
-            readonly 'lookups': {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
             readonly 'values': null;
+            readonly 'lookups': null;
         };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
     }
     namespace RESULT {
     }
-    type RESULT<F_Source> = _i_resolved._T_Schemas;
+    type RESULT<F_Source> = _i_resolved._T_Text_Type;
 }
-export declare namespace _T_Text_Type {
+export declare namespace Globals {
     namespace CONTEXT {
         type Source<F_Source> = F_Source;
     }
-    type CONTEXT<F_Source> = _i_unresolved._T_Text_Type<F_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Globals<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
-            namespace lookups {
-            }
-            type lookups<F_Source> = null;
             namespace values {
             }
             type values<F_Source> = null;
+            namespace lookups {
+            }
+            type lookups<F_Source> = null;
         }
         type parameters<F_Source> = {
-            readonly 'lookups': null;
             readonly 'values': null;
+            readonly 'lookups': null;
         };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
     }
     namespace RESULT {
     }
-    type RESULT<F_Source> = _i_resolved._T_Text_Type;
+    type RESULT<F_Source> = _i_resolved._T_Globals;
 }
-export declare namespace _T_Type {
+export declare namespace Group {
     namespace CONTEXT {
         type Source<F_Source> = F_Source;
     }
-    type CONTEXT<F_Source> = _i_unresolved._T_Type<F_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Group<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Globals;
+                }
+                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
             namespace lookups {
                 namespace noncircular_sibling_types {
                     namespace T {
@@ -482,51 +721,51 @@ export declare namespace _T_Type {
                 readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
                 readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _et.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _et.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-            };
         }
         type parameters<F_Source> = {
+            readonly 'values': {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
             readonly 'lookups': {
                 readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
                 readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
-            readonly 'values': {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-            };
         };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
     }
     namespace RESULT {
     }
-    type RESULT<F_Source> = _i_resolved._T_Type;
+    type RESULT<F_Source> = _i_resolved._T_Group;
 }
-export declare namespace _T_Type_Node {
+export declare namespace Dictionary {
     namespace CONTEXT {
         type Source<F_Source> = F_Source;
     }
-    type CONTEXT<F_Source> = _i_unresolved._T_Type_Node<F_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Dictionary<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Globals;
+                }
+                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
             namespace lookups {
                 namespace noncircular_sibling_types {
                     namespace T {
@@ -545,96 +784,51 @@ export declare namespace _T_Type_Node {
                 readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
                 readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _et.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _et.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-            };
         }
         type parameters<F_Source> = {
+            readonly 'values': {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
             readonly 'lookups': {
                 readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
                 readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
-            readonly 'values': {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-            };
         };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
     }
     namespace RESULT {
     }
-    type RESULT<F_Source> = _i_resolved._T_Type_Node;
+    type RESULT<F_Source> = _i_resolved._T_Dictionary;
 }
-export declare namespace _T_Types {
+export declare namespace Type_Node {
     namespace CONTEXT {
         type Source<F_Source> = F_Source;
     }
-    type CONTEXT<F_Source> = _i_unresolved._T_Types<F_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Type_Node<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
-            namespace lookups {
-            }
-            type lookups<F_Source> = null;
             namespace values {
                 namespace globals {
                     namespace O {
                     }
                     type O<F_Source> = _i_resolved._T_Globals;
                 }
-                type globals<F_Source> = _et.Optional_Value<_i_resolved._T_Globals>;
+                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
                 namespace imports {
                     namespace O {
                     }
                     type O<F_Source> = _i_resolved._T_Imports;
                 }
-                type imports<F_Source> = _et.Optional_Value<_i_resolved._T_Imports>;
+                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
             }
             type values<F_Source> = {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
             };
-        }
-        type parameters<F_Source> = {
-            readonly 'lookups': null;
-            readonly 'values': {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-            };
-        };
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Types;
-}
-export declare namespace Dictionary {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Dictionary<F_Source>;
-    namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-        namespace parameters {
             namespace lookups {
                 namespace noncircular_sibling_types {
                     namespace T {
@@ -653,78 +847,51 @@ export declare namespace Dictionary {
                 readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
                 readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _et.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _et.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-            };
         }
         type parameters<F_Source> = {
+            readonly 'values': {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
             readonly 'lookups': {
                 readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
                 readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
-            readonly 'values': {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-            };
         };
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Dictionary;
-}
-export declare namespace Globals {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Globals<F_Source>;
-    namespace PARAMS {
         namespace location_2_string {
             type Source<F_Source> = F_Source;
         }
         type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-        namespace parameters {
-            namespace lookups {
-            }
-            type lookups<F_Source> = null;
-            namespace values {
-            }
-            type values<F_Source> = null;
-        }
-        type parameters<F_Source> = {
-            readonly 'lookups': null;
-            readonly 'values': null;
-        };
     }
     namespace RESULT {
     }
-    type RESULT<F_Source> = _i_resolved._T_Globals;
+    type RESULT<F_Source> = _i_resolved._T_Type_Node;
 }
-export declare namespace Group {
+export declare namespace Type {
     namespace CONTEXT {
         type Source<F_Source> = F_Source;
     }
-    type CONTEXT<F_Source> = _i_unresolved._T_Group<F_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Type<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Globals;
+                }
+                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
             namespace lookups {
                 namespace noncircular_sibling_types {
                     namespace T {
@@ -743,88 +910,36 @@ export declare namespace Group {
                 readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
                 readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _et.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _et.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-            };
         }
         type parameters<F_Source> = {
+            readonly 'values': {
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
+            };
             readonly 'lookups': {
                 readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
                 readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
             };
-            readonly 'values': {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-            };
         };
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Group;
-}
-export declare namespace Imports {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Imports<F_Source>;
-    namespace PARAMS {
         namespace location_2_string {
             type Source<F_Source> = F_Source;
         }
         type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-        namespace parameters {
-            namespace lookups {
-                namespace sibling_schemas {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Schemas.D;
-                }
-                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-            namespace values {
-            }
-            type values<F_Source> = null;
-        }
-        type parameters<F_Source> = {
-            readonly 'lookups': {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-            readonly 'values': null;
-        };
     }
     namespace RESULT {
     }
-    type RESULT<F_Source> = _i_resolved._T_Imports;
+    type RESULT<F_Source> = _i_resolved._T_Type;
 }
-export declare namespace Schema {
+export declare namespace Schemas {
     namespace CONTEXT {
         type Source<F_Source> = F_Source;
     }
-    type CONTEXT<F_Source> = _i_unresolved._T_Schema<F_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Schemas<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
+            namespace values {
+            }
+            type values<F_Source> = null;
             namespace lookups {
                 namespace sibling_schemas {
                     namespace T {
@@ -836,20 +951,21 @@ export declare namespace Schema {
             type lookups<F_Source> = {
                 readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
             };
-            namespace values {
-            }
-            type values<F_Source> = null;
         }
         type parameters<F_Source> = {
+            readonly 'values': null;
             readonly 'lookups': {
                 readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
             };
-            readonly 'values': null;
         };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
     }
     namespace RESULT {
     }
-    type RESULT<F_Source> = _i_resolved._T_Schema;
+    type RESULT<F_Source> = _i_resolved._T_Schemas;
 }
 export declare namespace Schema_Tree {
     namespace CONTEXT {
@@ -857,11 +973,10 @@ export declare namespace Schema_Tree {
     }
     type CONTEXT<F_Source> = _i_unresolved._T_Schema_Tree<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
+            namespace values {
+            }
+            type values<F_Source> = null;
             namespace lookups {
                 namespace sibling_schemas {
                     namespace T {
@@ -873,32 +988,32 @@ export declare namespace Schema_Tree {
             type lookups<F_Source> = {
                 readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
             };
-            namespace values {
-            }
-            type values<F_Source> = null;
         }
         type parameters<F_Source> = {
+            readonly 'values': null;
             readonly 'lookups': {
                 readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
             };
-            readonly 'values': null;
         };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
     }
     namespace RESULT {
     }
     type RESULT<F_Source> = _i_resolved._T_Schema_Tree;
 }
-export declare namespace Schemas {
+export declare namespace Schema {
     namespace CONTEXT {
         type Source<F_Source> = F_Source;
     }
-    type CONTEXT<F_Source> = _i_unresolved._T_Schemas<F_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Schema<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
+            namespace values {
+            }
+            type values<F_Source> = null;
             namespace lookups {
                 namespace sibling_schemas {
                     namespace T {
@@ -910,173 +1025,58 @@ export declare namespace Schemas {
             type lookups<F_Source> = {
                 readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
             };
-            namespace values {
-            }
-            type values<F_Source> = null;
         }
         type parameters<F_Source> = {
+            readonly 'values': null;
             readonly 'lookups': {
                 readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
             };
-            readonly 'values': null;
         };
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Schemas;
-}
-export declare namespace Text_Type {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Text_Type<F_Source>;
-    namespace PARAMS {
         namespace location_2_string {
             type Source<F_Source> = F_Source;
         }
         type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-        namespace parameters {
-            namespace lookups {
-            }
-            type lookups<F_Source> = null;
-            namespace values {
-            }
-            type values<F_Source> = null;
-        }
-        type parameters<F_Source> = {
-            readonly 'lookups': null;
-            readonly 'values': null;
-        };
     }
     namespace RESULT {
     }
-    type RESULT<F_Source> = _i_resolved._T_Text_Type;
+    type RESULT<F_Source> = _i_resolved._T_Schema;
 }
-export declare namespace Type {
+export declare namespace Imports {
     namespace CONTEXT {
         type Source<F_Source> = F_Source;
     }
-    type CONTEXT<F_Source> = _i_unresolved._T_Type<F_Source>;
+    type CONTEXT<F_Source> = _i_unresolved._T_Imports<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
+            namespace values {
+            }
+            type values<F_Source> = null;
             namespace lookups {
-                namespace noncircular_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type noncircular_sibling_types<F_Source> = _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                namespace possibly_circular_dependent_sibling_types {
+                namespace sibling_schemas {
                     namespace T {
                     }
-                    type T<F_Source> = _i_resolved._T_Types.D;
+                    type T<F_Source> = _i_resolved._T_Schemas.D;
                 }
-                type possibly_circular_dependent_sibling_types<F_Source> = _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
             }
             type lookups<F_Source> = {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _et.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _et.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
             };
         }
         type parameters<F_Source> = {
+            readonly 'values': null;
             readonly 'lookups': {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-            readonly 'values': {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
             };
         };
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Type;
-}
-export declare namespace Type_Node {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Type_Node<F_Source>;
-    namespace PARAMS {
         namespace location_2_string {
             type Source<F_Source> = F_Source;
         }
         type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-        namespace parameters {
-            namespace lookups {
-                namespace noncircular_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type noncircular_sibling_types<F_Source> = _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                namespace possibly_circular_dependent_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type possibly_circular_dependent_sibling_types<F_Source> = _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _et.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _et.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'lookups': {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-            readonly 'values': {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
-            };
-        };
     }
     namespace RESULT {
     }
-    type RESULT<F_Source> = _i_resolved._T_Type_Node;
+    type RESULT<F_Source> = _i_resolved._T_Imports;
 }
 export declare namespace Types {
     namespace CONTEXT {
@@ -1084,40 +1084,40 @@ export declare namespace Types {
     }
     type CONTEXT<F_Source> = _i_unresolved._T_Types<F_Source>;
     namespace PARAMS {
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
         namespace parameters {
-            namespace lookups {
-            }
-            type lookups<F_Source> = null;
             namespace values {
                 namespace globals {
                     namespace O {
                     }
                     type O<F_Source> = _i_resolved._T_Globals;
                 }
-                type globals<F_Source> = _et.Optional_Value<_i_resolved._T_Globals>;
+                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
                 namespace imports {
                     namespace O {
                     }
                     type O<F_Source> = _i_resolved._T_Imports;
                 }
-                type imports<F_Source> = _et.Optional_Value<_i_resolved._T_Imports>;
+                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
             }
             type values<F_Source> = {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
             };
+            namespace lookups {
+            }
+            type lookups<F_Source> = null;
         }
         type parameters<F_Source> = {
-            readonly 'lookups': null;
             readonly 'values': {
-                readonly 'globals': _et.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _et.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
             };
+            readonly 'lookups': null;
         };
+        namespace location_2_string {
+            type Source<F_Source> = F_Source;
+        }
+        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
     }
     namespace RESULT {
     }