pareto 0.76.1 → 0.76.3

package/dist/generated/interface/schemas/schema/resolve.d.ts

@@ -0,0 +1,4401 @@
+import * as _pt from 'exupery-core-types';
+import * as _i_generic from "../../../generic/resolve";
+import * as _i_resolved from "./resolved";
+import * as _i_unresolved from "./unresolved";
+export type _T_Benchmark<G_Source> = ($$_: _i_unresolved._T_Benchmark<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+        };
+        readonly 'values': {
+            readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'definition': _i_resolved._T_Type_Node;
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+            readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+            readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+            readonly 'signature': _i_resolved._T_Signature;
+            readonly 'signatures': _i_resolved._T_Signatures;
+            readonly 'types': _i_resolved._T_Types;
+        };
+    };
+}) => _i_resolved._T_Benchmark;
+export type _T_Constraint<G_Source> = ($$_: _i_unresolved._T_Constraint<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': {
+            readonly 'node': _i_resolved._T_Type_Node;
+        };
+    };
+}) => _i_resolved._T_Constraint;
+export type _T_Dictionary<G_Source> = ($$_: _i_unresolved._T_Dictionary<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            readonly 'possibly circular dependent sibling types': _i_generic._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>;
+            readonly 'type parameters': _i_resolved._T_Type_Parameters;
+        };
+    };
+}) => _i_resolved._T_Dictionary;
+export type _T_Globals<G_Source> = ($$_: _i_unresolved._T_Globals<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': null;
+    };
+}) => _i_resolved._T_Globals;
+export type _T_Group<G_Source> = ($$_: _i_unresolved._T_Group<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            readonly 'possibly circular dependent sibling types': _i_generic._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>;
+            readonly 'type parameters': _i_resolved._T_Type_Parameters;
+        };
+    };
+}) => _i_resolved._T_Group;
+export type _T_Guaranteed_Value_Selection<G_Source> = ($$_: _i_unresolved._T_Guaranteed_Value_Selection<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+        };
+        readonly 'values': {
+            readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'definition': _i_resolved._T_Type_Node;
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+            readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+            readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+            readonly 'signature': _i_resolved._T_Signature;
+            readonly 'signatures': _i_resolved._T_Signatures;
+            readonly 'types': _i_resolved._T_Types;
+        };
+    };
+}) => _i_resolved._T_Guaranteed_Value_Selection;
+export type _T_Imports<G_Source> = ($$_: _i_unresolved._T_Imports<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+        };
+        readonly 'values': null;
+    };
+}) => _i_resolved._T_Imports;
+export type _T_Lookup_Selection<G_Source> = ($$_: _i_unresolved._T_Lookup_Selection<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+        };
+        readonly 'values': {
+            readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'definition': _i_resolved._T_Type_Node;
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+            readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+            readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+            readonly 'signature': _i_resolved._T_Signature;
+            readonly 'signatures': _i_resolved._T_Signatures;
+            readonly 'types': _i_resolved._T_Types;
+        };
+    };
+}) => _i_resolved._T_Lookup_Selection;
+export type _T_Node_Resolver<G_Source> = ($$_: _i_unresolved._T_Node_Resolver<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+        };
+        readonly 'values': {
+            readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'definition': _i_resolved._T_Type_Node;
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+            readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+            readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+            readonly 'signature': _i_resolved._T_Signature;
+            readonly 'signatures': _i_resolved._T_Signatures;
+            readonly 'types': _i_resolved._T_Types;
+        };
+    };
+}) => _i_resolved._T_Node_Resolver;
+export type _T_Node_Resolver_Group<G_Source> = ($$_: _i_unresolved._T_Node_Resolver_Group<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+        };
+        readonly 'values': {
+            readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'definition': _i_resolved._T_Group;
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+            readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+            readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+            readonly 'signature': _i_resolved._T_Signature;
+            readonly 'signatures': _i_resolved._T_Signatures;
+            readonly 'types': _i_resolved._T_Types;
+        };
+    };
+}) => _i_resolved._T_Node_Resolver_Group;
+export type _T_Node_Resolver_List_Result<G_Source> = ($$_: _i_unresolved._T_Node_Resolver_List_Result<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+        };
+        readonly 'values': {
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+        };
+    };
+}) => _i_resolved._T_Node_Resolver_List_Result;
+export type _T_Number_Type<G_Source> = ($$_: _i_unresolved._T_Number_Type<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': null;
+    };
+}) => _i_resolved._T_Number_Type;
+export type _T_Option_Constraints<G_Source> = ($$_: _i_unresolved._T_Option_Constraints<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+        };
+        readonly 'values': {
+            readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'definition': _i_resolved._T_Type_Node;
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+            readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+            readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+            readonly 'signature': _i_resolved._T_Signature;
+            readonly 'signatures': _i_resolved._T_Signatures;
+            readonly 'types': _i_resolved._T_Types;
+        };
+    };
+}) => _i_resolved._T_Option_Constraints;
+export type _T_Optional_Value_Initialization<G_Source> = ($$_: _i_unresolved._T_Optional_Value_Initialization<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+        };
+        readonly 'values': {
+            readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'definition': _i_resolved._T_Type_Node;
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+            readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+            readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+            readonly 'signature': _i_resolved._T_Signature;
+            readonly 'signatures': _i_resolved._T_Signatures;
+            readonly 'types': _i_resolved._T_Types;
+        };
+    };
+}) => _i_resolved._T_Optional_Value_Initialization;
+export type _T_Possible_Value_Selection<G_Source> = ($$_: _i_unresolved._T_Possible_Value_Selection<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+        };
+        readonly 'values': {
+            readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+            readonly 'definition': _i_resolved._T_Type_Node;
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+            readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+            readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+            readonly 'signature': _i_resolved._T_Signature;
+            readonly 'signatures': _i_resolved._T_Signatures;
+            readonly 'types': _i_resolved._T_Types;
+        };
+    };
+}) => _i_resolved._T_Possible_Value_Selection;
+export type _T_Presence<G_Source> = ($$_: _i_unresolved._T_Presence<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': null;
+    };
+}) => _i_resolved._T_Presence;
+export type _T_Property_Constraint<G_Source> = ($$_: _i_unresolved._T_Property_Constraint<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'property constraints': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+        };
+        readonly 'values': null;
+    };
+}) => _i_resolved._T_Property_Constraint;
+export type _T_Property_Constraints<G_Source> = ($$_: _i_unresolved._T_Property_Constraints<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': {
+            readonly 'node': _i_resolved._T_Type_Node;
+        };
+    };
+}) => _i_resolved._T_Property_Constraints;
+export type _T_Reference_To_Property_Constraint<G_Source> = ($$_: _i_unresolved._T_Reference_To_Property_Constraint<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'property constraints': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+        };
+        readonly 'values': null;
+    };
+}) => _i_resolved._T_Reference_To_Property_Constraint;
+export type _T_Relative_Value_Selection<G_Source> = ($$_: _i_unresolved._T_Relative_Value_Selection<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': {
+            readonly 'node': _i_resolved._T_Type_Node;
+        };
+    };
+}) => _i_resolved._T_Relative_Value_Selection;
+export type _T_Resolve_Logic<G_Source> = ($$_: _i_unresolved._T_Resolve_Logic<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': {
+            readonly 'imports': _i_resolved._T_Imports;
+            readonly 'types': _i_resolved._T_Types;
+        };
+    };
+}) => _i_resolved._T_Resolve_Logic;
+export type _T_Resolvers<G_Source> = ($$_: _i_unresolved._T_Resolvers<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': {
+            readonly 'imports': _i_resolved._T_Imports;
+            readonly 'signatures': _i_resolved._T_Signatures;
+            readonly 'types': _i_resolved._T_Types;
+        };
+    };
+}) => _i_resolved._T_Resolvers;
+export type _T_Schemas<G_Source> = ($$_: _i_unresolved._T_Schemas<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+        };
+        readonly 'values': null;
+    };
+}) => _i_resolved._T_Schemas;
+export type _T_Signature<G_Source> = ($$_: _i_unresolved._T_Signature<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'sibling signatures': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Signatures.D>;
+        };
+        readonly 'values': {
+            readonly 'imports': _i_resolved._T_Imports;
+            readonly 'type': _i_resolved._T_Type;
+            readonly 'types': _i_resolved._T_Types;
+        };
+    };
+}) => _i_resolved._T_Signature;
+export type _T_Signature_Parameters<G_Source> = ($$_: _i_unresolved._T_Signature_Parameters<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': {
+            readonly 'imports': _i_resolved._T_Imports;
+            readonly 'types': _i_resolved._T_Types;
+        };
+    };
+}) => _i_resolved._T_Signature_Parameters;
+export type _T_Signatures<G_Source> = ($$_: _i_unresolved._T_Signatures<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': {
+            readonly 'imports': _i_resolved._T_Imports;
+            readonly 'types': _i_resolved._T_Types;
+        };
+    };
+}) => _i_resolved._T_Signatures;
+export type _T_Text_Type<G_Source> = ($$_: _i_unresolved._T_Text_Type<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': null;
+    };
+}) => _i_resolved._T_Text_Type;
+export type _T_Type<G_Source> = ($$_: _i_unresolved._T_Type<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            readonly 'possibly circular dependent sibling types': _i_generic._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<G_Source> = ($$_: _i_unresolved._T_Type_Node<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            readonly 'possibly circular dependent sibling types': _i_generic._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>;
+            readonly 'type parameters': _i_resolved._T_Type_Parameters;
+        };
+    };
+}) => _i_resolved._T_Type_Node;
+export type _T_Type_Node_Reference<G_Source> = ($$_: _i_unresolved._T_Type_Node_Reference<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+        };
+        readonly 'values': {
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+        };
+    };
+}) => _i_resolved._T_Type_Node_Reference;
+export type _T_Type_Parameters<G_Source> = ($$_: _i_unresolved._T_Type_Parameters<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': null;
+        readonly 'values': null;
+    };
+}) => _i_resolved._T_Type_Parameters;
+export type _T_Type_Reference<G_Source> = ($$_: _i_unresolved._T_Type_Reference<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+        };
+        readonly 'values': {
+            readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+        };
+    };
+}) => _i_resolved._T_Type_Reference;
+export type _T_Types<G_Source> = ($$_: _i_unresolved._T_Types<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_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 Benchmark<G_Source> = _T_Benchmark<G_Source>;
+export type Constraint<G_Source> = _T_Constraint<G_Source>;
+export type Dictionary<G_Source> = _T_Dictionary<G_Source>;
+export type Globals<G_Source> = _T_Globals<G_Source>;
+export type Group<G_Source> = _T_Group<G_Source>;
+export type Guaranteed_Value_Selection<G_Source> = _T_Guaranteed_Value_Selection<G_Source>;
+export type Imports<G_Source> = _T_Imports<G_Source>;
+export type Lookup_Selection<G_Source> = _T_Lookup_Selection<G_Source>;
+export type Node_Resolver<G_Source> = _T_Node_Resolver<G_Source>;
+export type Node_Resolver_Group<G_Source> = _T_Node_Resolver_Group<G_Source>;
+export type Node_Resolver_List_Result<G_Source> = _T_Node_Resolver_List_Result<G_Source>;
+export type Number_Type<G_Source> = _T_Number_Type<G_Source>;
+export type Option_Constraints<G_Source> = _T_Option_Constraints<G_Source>;
+export type Optional_Value_Initialization<G_Source> = _T_Optional_Value_Initialization<G_Source>;
+export type Possible_Value_Selection<G_Source> = _T_Possible_Value_Selection<G_Source>;
+export type Presence<G_Source> = _T_Presence<G_Source>;
+export type Property_Constraint<G_Source> = _T_Property_Constraint<G_Source>;
+export type Property_Constraints<G_Source> = _T_Property_Constraints<G_Source>;
+export type Reference_To_Property_Constraint<G_Source> = _T_Reference_To_Property_Constraint<G_Source>;
+export type Relative_Value_Selection<G_Source> = _T_Relative_Value_Selection<G_Source>;
+export type Resolve_Logic<G_Source> = _T_Resolve_Logic<G_Source>;
+export type Resolvers<G_Source> = _T_Resolvers<G_Source>;
+export type Schemas<G_Source> = _T_Schemas<G_Source>;
+export type Signature<G_Source> = _T_Signature<G_Source>;
+export type Signature_Parameters<G_Source> = _T_Signature_Parameters<G_Source>;
+export type Signatures<G_Source> = _T_Signatures<G_Source>;
+export type Text_Type<G_Source> = _T_Text_Type<G_Source>;
+export type Type<G_Source> = _T_Type<G_Source>;
+export type Type_Node<G_Source> = _T_Type_Node<G_Source>;
+export type Type_Node_Reference<G_Source> = _T_Type_Node_Reference<G_Source>;
+export type Type_Parameters<G_Source> = _T_Type_Parameters<G_Source>;
+export type Type_Reference<G_Source> = _T_Type_Reference<G_Source>;
+export type Types<G_Source> = _T_Types<G_Source>;
+export declare namespace _T_Benchmark {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Benchmark<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Benchmark;
+}
+export declare namespace _T_Constraint {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Constraint<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace node {
+                }
+                type node<G_Source> = _i_resolved._T_Type_Node;
+            }
+            type values<G_Source> = {
+                readonly 'node': _i_resolved._T_Type_Node;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'node': _i_resolved._T_Type_Node;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Constraint;
+}
+export declare namespace _T_Dictionary {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Dictionary<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace noncircular_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type noncircular_sibling_types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                namespace possibly_circular_dependent_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type possibly_circular_dependent_sibling_types<G_Source> = _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Globals;
+                }
+                type globals<G_Source> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace type_parameters {
+                }
+                type type_parameters<G_Source> = _i_resolved._T_Type_Parameters;
+            }
+            type values<G_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'type parameters': _i_resolved._T_Type_Parameters;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._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>;
+                readonly 'type parameters': _i_resolved._T_Type_Parameters;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Dictionary;
+}
+export declare namespace _T_Globals {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Globals<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Globals;
+}
+export declare namespace _T_Group {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Group<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace noncircular_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type noncircular_sibling_types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                namespace possibly_circular_dependent_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type possibly_circular_dependent_sibling_types<G_Source> = _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Globals;
+                }
+                type globals<G_Source> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace type_parameters {
+                }
+                type type_parameters<G_Source> = _i_resolved._T_Type_Parameters;
+            }
+            type values<G_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'type parameters': _i_resolved._T_Type_Parameters;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._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>;
+                readonly 'type parameters': _i_resolved._T_Type_Parameters;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Group;
+}
+export declare namespace _T_Guaranteed_Value_Selection {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Guaranteed_Value_Selection<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Guaranteed_Value_Selection;
+}
+export declare namespace _T_Imports {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Imports<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace sibling_schemas {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Schemas.D;
+                }
+                type sibling_schemas<G_Source> = _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Imports;
+}
+export declare namespace _T_Lookup_Selection {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Lookup_Selection<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Lookup_Selection;
+}
+export declare namespace _T_Node_Resolver {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Node_Resolver<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Node_Resolver;
+}
+export declare namespace _T_Node_Resolver_Group {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Node_Resolver_Group<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Group;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Group;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Group;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Node_Resolver_Group;
+}
+export declare namespace _T_Node_Resolver_List_Result {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Node_Resolver_List_Result<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            readonly 'values': {
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+}
+export declare namespace _T_Number_Type {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Number_Type<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Number_Type;
+}
+export declare namespace _T_Option_Constraints {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Option_Constraints<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Option_Constraints;
+}
+export declare namespace _T_Optional_Value_Initialization {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Optional_Value_Initialization<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Optional_Value_Initialization;
+}
+export declare namespace _T_Possible_Value_Selection {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Possible_Value_Selection<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Possible_Value_Selection;
+}
+export declare namespace _T_Presence {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Presence<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Presence;
+}
+export declare namespace _T_Property_Constraint {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Property_Constraint<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace property_constraints {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Property_Constraints.D;
+                }
+                type property_constraints<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'property constraints': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+            };
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'property constraints': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+            };
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Property_Constraint;
+}
+export declare namespace _T_Property_Constraints {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Property_Constraints<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace node {
+                }
+                type node<G_Source> = _i_resolved._T_Type_Node;
+            }
+            type values<G_Source> = {
+                readonly 'node': _i_resolved._T_Type_Node;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'node': _i_resolved._T_Type_Node;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Property_Constraints;
+}
+export declare namespace _T_Reference_To_Property_Constraint {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Reference_To_Property_Constraint<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace property_constraints {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Property_Constraints.D;
+                }
+                type property_constraints<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'property constraints': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+            };
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'property constraints': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+            };
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Reference_To_Property_Constraint;
+}
+export declare namespace _T_Relative_Value_Selection {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Relative_Value_Selection<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace node {
+                }
+                type node<G_Source> = _i_resolved._T_Type_Node;
+            }
+            type values<G_Source> = {
+                readonly 'node': _i_resolved._T_Type_Node;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'node': _i_resolved._T_Type_Node;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Relative_Value_Selection;
+}
+export declare namespace _T_Resolve_Logic {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Resolve_Logic<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace imports {
+                }
+                type imports<G_Source> = _i_resolved._T_Imports;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Resolve_Logic;
+}
+export declare namespace _T_Resolvers {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Resolvers<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace imports {
+                }
+                type imports<G_Source> = _i_resolved._T_Imports;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Resolvers;
+}
+export declare namespace _T_Schemas {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Schemas<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace sibling_schemas {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Schemas.D;
+                }
+                type sibling_schemas<G_Source> = _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Schemas;
+}
+export declare namespace _T_Signature {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Signature<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace sibling_signatures {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Signatures.D;
+                }
+                type sibling_signatures<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Signatures.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'sibling signatures': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Signatures.D>;
+            };
+            namespace values {
+                namespace imports {
+                }
+                type imports<G_Source> = _i_resolved._T_Imports;
+                namespace _type {
+                }
+                type _type<G_Source> = _i_resolved._T_Type;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'type': _i_resolved._T_Type;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'sibling signatures': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Signatures.D>;
+            };
+            readonly 'values': {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'type': _i_resolved._T_Type;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Signature;
+}
+export declare namespace _T_Signature_Parameters {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Signature_Parameters<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace imports {
+                }
+                type imports<G_Source> = _i_resolved._T_Imports;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Signature_Parameters;
+}
+export declare namespace _T_Signatures {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Signatures<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace imports {
+                }
+                type imports<G_Source> = _i_resolved._T_Imports;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Signatures;
+}
+export declare namespace _T_Text_Type {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Text_Type<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Text_Type;
+}
+export declare namespace _T_Type {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Type<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace noncircular_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type noncircular_sibling_types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                namespace possibly_circular_dependent_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type possibly_circular_dependent_sibling_types<G_Source> = _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Globals;
+                }
+                type globals<G_Source> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<G_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._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<G_Source> = _i_resolved._T_Type;
+}
+export declare namespace _T_Type_Node {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Type_Node<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace noncircular_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type noncircular_sibling_types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                namespace possibly_circular_dependent_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type possibly_circular_dependent_sibling_types<G_Source> = _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Globals;
+                }
+                type globals<G_Source> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace type_parameters {
+                }
+                type type_parameters<G_Source> = _i_resolved._T_Type_Parameters;
+            }
+            type values<G_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'type parameters': _i_resolved._T_Type_Parameters;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._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>;
+                readonly 'type parameters': _i_resolved._T_Type_Parameters;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Type_Node;
+}
+export declare namespace _T_Type_Node_Reference {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Type_Node_Reference<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            readonly 'values': {
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Type_Node_Reference;
+}
+export declare namespace _T_Type_Parameters {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Type_Parameters<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Type_Parameters;
+}
+export declare namespace _T_Type_Reference {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Type_Reference<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            readonly 'values': {
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Type_Reference;
+}
+export declare namespace _T_Types {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Types<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Globals;
+                }
+                type globals<G_Source> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<G_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        }
+        type parameters<G_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<G_Source> = _i_resolved._T_Types;
+}
+export declare namespace Benchmark {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Benchmark<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Benchmark;
+}
+export declare namespace Constraint {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Constraint<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace node {
+                }
+                type node<G_Source> = _i_resolved._T_Type_Node;
+            }
+            type values<G_Source> = {
+                readonly 'node': _i_resolved._T_Type_Node;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'node': _i_resolved._T_Type_Node;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Constraint;
+}
+export declare namespace Dictionary {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Dictionary<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace noncircular_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type noncircular_sibling_types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                namespace possibly_circular_dependent_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type possibly_circular_dependent_sibling_types<G_Source> = _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Globals;
+                }
+                type globals<G_Source> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace type_parameters {
+                }
+                type type_parameters<G_Source> = _i_resolved._T_Type_Parameters;
+            }
+            type values<G_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'type parameters': _i_resolved._T_Type_Parameters;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._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>;
+                readonly 'type parameters': _i_resolved._T_Type_Parameters;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Dictionary;
+}
+export declare namespace Globals {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Globals<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Globals;
+}
+export declare namespace Group {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Group<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace noncircular_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type noncircular_sibling_types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                namespace possibly_circular_dependent_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type possibly_circular_dependent_sibling_types<G_Source> = _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Globals;
+                }
+                type globals<G_Source> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace type_parameters {
+                }
+                type type_parameters<G_Source> = _i_resolved._T_Type_Parameters;
+            }
+            type values<G_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'type parameters': _i_resolved._T_Type_Parameters;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._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>;
+                readonly 'type parameters': _i_resolved._T_Type_Parameters;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Group;
+}
+export declare namespace Guaranteed_Value_Selection {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Guaranteed_Value_Selection<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Guaranteed_Value_Selection;
+}
+export declare namespace Imports {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Imports<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace sibling_schemas {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Schemas.D;
+                }
+                type sibling_schemas<G_Source> = _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Imports;
+}
+export declare namespace Lookup_Selection {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Lookup_Selection<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Lookup_Selection;
+}
+export declare namespace Node_Resolver {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Node_Resolver<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Node_Resolver;
+}
+export declare namespace Node_Resolver_Group {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Node_Resolver_Group<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Group;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Group;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Group;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Node_Resolver_Group;
+}
+export declare namespace Node_Resolver_List_Result {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Node_Resolver_List_Result<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            readonly 'values': {
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+}
+export declare namespace Number_Type {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Number_Type<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Number_Type;
+}
+export declare namespace Option_Constraints {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Option_Constraints<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Option_Constraints;
+}
+export declare namespace Optional_Value_Initialization {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Optional_Value_Initialization<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Optional_Value_Initialization;
+}
+export declare namespace Possible_Value_Selection {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Possible_Value_Selection<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace parent_sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type parent_sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                namespace sibling_property_resolvers {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Node_Resolver_Group.D;
+                }
+                type sibling_property_resolvers<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            namespace values {
+                namespace current_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace current_ordered_dictionary {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Dictionary;
+                }
+                type current_ordered_dictionary<G_Source> = _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                namespace definition {
+                }
+                type definition<G_Source> = _i_resolved._T_Type_Node;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace linked_entry {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Benchmark;
+                }
+                type linked_entry<G_Source> = _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                namespace list_cursor {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Node_Resolver_List_Result;
+                }
+                type list_cursor<G_Source> = _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                namespace option_constraints {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Option_Constraints;
+                }
+                type option_constraints<G_Source> = _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                namespace signature {
+                }
+                type signature<G_Source> = _i_resolved._T_Signature;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'parent sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+                readonly 'sibling property resolvers': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Node_Resolver_Group.D>;
+            };
+            readonly 'values': {
+                readonly 'current dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'current ordered dictionary': _pt.Optional_Value<_i_resolved._T_Dictionary>;
+                readonly 'definition': _i_resolved._T_Type_Node;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'linked entry': _pt.Optional_Value<_i_resolved._T_Benchmark>;
+                readonly 'list cursor': _pt.Optional_Value<_i_resolved._T_Node_Resolver_List_Result>;
+                readonly 'option constraints': _pt.Optional_Value<_i_resolved._T_Option_Constraints>;
+                readonly 'signature': _i_resolved._T_Signature;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Possible_Value_Selection;
+}
+export declare namespace Presence {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Presence<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Presence;
+}
+export declare namespace Property_Constraint {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Property_Constraint<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace property_constraints {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Property_Constraints.D;
+                }
+                type property_constraints<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'property constraints': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+            };
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'property constraints': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+            };
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Property_Constraint;
+}
+export declare namespace Property_Constraints {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Property_Constraints<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace node {
+                }
+                type node<G_Source> = _i_resolved._T_Type_Node;
+            }
+            type values<G_Source> = {
+                readonly 'node': _i_resolved._T_Type_Node;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'node': _i_resolved._T_Type_Node;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Property_Constraints;
+}
+export declare namespace Reference_To_Property_Constraint {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Reference_To_Property_Constraint<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace property_constraints {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Property_Constraints.D;
+                }
+                type property_constraints<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'property constraints': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+            };
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'property constraints': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Property_Constraints.D>;
+            };
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Reference_To_Property_Constraint;
+}
+export declare namespace Relative_Value_Selection {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Relative_Value_Selection<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace node {
+                }
+                type node<G_Source> = _i_resolved._T_Type_Node;
+            }
+            type values<G_Source> = {
+                readonly 'node': _i_resolved._T_Type_Node;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'node': _i_resolved._T_Type_Node;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Relative_Value_Selection;
+}
+export declare namespace Resolve_Logic {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Resolve_Logic<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace imports {
+                }
+                type imports<G_Source> = _i_resolved._T_Imports;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Resolve_Logic;
+}
+export declare namespace Resolvers {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Resolvers<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace imports {
+                }
+                type imports<G_Source> = _i_resolved._T_Imports;
+                namespace signatures {
+                }
+                type signatures<G_Source> = _i_resolved._T_Signatures;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'signatures': _i_resolved._T_Signatures;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Resolvers;
+}
+export declare namespace Schemas {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Schemas<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace sibling_schemas {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Schemas.D;
+                }
+                type sibling_schemas<G_Source> = _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Schemas;
+}
+export declare namespace Signature {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Signature<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace sibling_signatures {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Signatures.D;
+                }
+                type sibling_signatures<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Signatures.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'sibling signatures': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Signatures.D>;
+            };
+            namespace values {
+                namespace imports {
+                }
+                type imports<G_Source> = _i_resolved._T_Imports;
+                namespace _type {
+                }
+                type _type<G_Source> = _i_resolved._T_Type;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'type': _i_resolved._T_Type;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'sibling signatures': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Signatures.D>;
+            };
+            readonly 'values': {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'type': _i_resolved._T_Type;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Signature;
+}
+export declare namespace Signature_Parameters {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Signature_Parameters<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace imports {
+                }
+                type imports<G_Source> = _i_resolved._T_Imports;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Signature_Parameters;
+}
+export declare namespace Signatures {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Signatures<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace imports {
+                }
+                type imports<G_Source> = _i_resolved._T_Imports;
+                namespace types {
+                }
+                type types<G_Source> = _i_resolved._T_Types;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': {
+                readonly 'imports': _i_resolved._T_Imports;
+                readonly 'types': _i_resolved._T_Types;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Signatures;
+}
+export declare namespace Text_Type {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Text_Type<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Text_Type;
+}
+export declare namespace Type {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Type<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace noncircular_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type noncircular_sibling_types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                namespace possibly_circular_dependent_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type possibly_circular_dependent_sibling_types<G_Source> = _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Globals;
+                }
+                type globals<G_Source> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<G_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._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<G_Source> = _i_resolved._T_Type;
+}
+export declare namespace Type_Node {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Type_Node<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace noncircular_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type noncircular_sibling_types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                namespace possibly_circular_dependent_sibling_types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type possibly_circular_dependent_sibling_types<G_Source> = _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Globals;
+                }
+                type globals<G_Source> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+                namespace type_parameters {
+                }
+                type type_parameters<G_Source> = _i_resolved._T_Type_Parameters;
+            }
+            type values<G_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+                readonly 'type parameters': _i_resolved._T_Type_Parameters;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'noncircular sibling types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+                readonly 'possibly circular dependent sibling types': _i_generic._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>;
+                readonly 'type parameters': _i_resolved._T_Type_Parameters;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Type_Node;
+}
+export declare namespace Type_Node_Reference {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Type_Node_Reference<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            readonly 'values': {
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Type_Node_Reference;
+}
+export declare namespace Type_Parameters {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Type_Parameters<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': null;
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Type_Parameters;
+}
+export declare namespace Type_Reference {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Type_Reference<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace types {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Types.D;
+                }
+                type types<G_Source> = _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            namespace values {
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<G_Source> = {
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'types': _i_generic._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
+            };
+            readonly 'values': {
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Type_Reference;
+}
+export declare namespace Types {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Types<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+            }
+            type lookups<G_Source> = null;
+            namespace values {
+                namespace globals {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Globals;
+                }
+                type globals<G_Source> = _pt.Optional_Value<_i_resolved._T_Globals>;
+                namespace imports {
+                    namespace O {
+                    }
+                    type O<G_Source> = _i_resolved._T_Imports;
+                }
+                type imports<G_Source> = _pt.Optional_Value<_i_resolved._T_Imports>;
+            }
+            type values<G_Source> = {
+                readonly 'globals': _pt.Optional_Value<_i_resolved._T_Globals>;
+                readonly 'imports': _pt.Optional_Value<_i_resolved._T_Imports>;
+            };
+        }
+        type parameters<G_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<G_Source> = _i_resolved._T_Types;
+}