pareto 0.76.60 → 0.76.61

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

@@ -0,0 +1,1125 @@
+import * as _pt from 'exupery-core-types';
+import * as _i_resolve from "../../../core/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>;
+    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': _pt.Optional_Value<_i_resolved._T_Globals>;
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+        };
+    };
+}) => _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>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': null;
+    };
+}) => _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 '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': _pt.Optional_Value<_i_resolved._T_Globals>;
+            readonly 'imports': _pt.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>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.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>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.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>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.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>;
+    readonly 'parameters': {
+        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>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': null;
+    };
+}) => _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>;
+    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': _pt.Optional_Value<_i_resolved._T_Globals>;
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+        };
+    };
+}) => _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>;
+    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': _pt.Optional_Value<_i_resolved._T_Globals>;
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+        };
+    };
+}) => _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>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': {
+            readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+        };
+    };
+}) => _i_resolved._T_Types;
+export type Dictionary = _T_Dictionary;
+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 Type_Node = _T_Type_Node;
+export type Types = _T_Types;
+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 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> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.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': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.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;
+}
+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 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> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.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': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<F_Source> = _i_resolved._T_Group;
+}
+export declare namespace _T_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;
+}
+export declare namespace _T_Schema {
+    namespace CONTEXT {
+        type Source<F_Source> = 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 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_Schema;
+}
+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 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_Schema_Tree;
+}
+export declare namespace _T_Schemas {
+    namespace CONTEXT {
+        type Source<F_Source> = 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 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_Schemas;
+}
+export declare namespace _T_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;
+}
+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 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> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.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': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<F_Source> = _i_resolved._T_Type;
+}
+export declare namespace _T_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> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.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': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<F_Source> = _i_resolved._T_Type_Node;
+}
+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 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> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        }
+        type parameters<F_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.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 {
+                    }
+                    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> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.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': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.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;
+}
+export declare namespace Group {
+    namespace CONTEXT {
+        type Source<F_Source> = 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 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> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.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': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.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;
+}
+export declare namespace Schema {
+    namespace CONTEXT {
+        type Source<F_Source> = 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 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_Schema;
+}
+export declare namespace Schema_Tree {
+    namespace CONTEXT {
+        type Source<F_Source> = F_Source;
+    }
+    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 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_Schema_Tree;
+}
+export declare namespace Schemas {
+    namespace CONTEXT {
+        type Source<F_Source> = 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 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_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;
+}
+export declare namespace Type {
+    namespace CONTEXT {
+        type Source<F_Source> = 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 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> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.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': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        };
+    }
+    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> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.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': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<F_Source> = _i_resolved._T_Type_Node;
+}
+export declare namespace Types {
+    namespace CONTEXT {
+        type Source<F_Source> = F_Source;
+    }
+    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> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<F_Source> = _i_resolved._T_Imports;
+                }
+                type imports<F_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<F_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        }
+        type parameters<F_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<F_Source> = _i_resolved._T_Types;
+}