pareto-liana 0.0.0 → 0.0.3

package/dist/interface/generated/liana/schemas/schema/data/unresolved.d.ts

@@ -0,0 +1,1594 @@
+import * as _pi from "pareto-core/dist/interface";
+import * as i__location from "astn-core/dist/interface/generated/liana/schemas/location/data";
+export declare namespace Schemas_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_dictionary {
+        namespace D {
+            type l_location = i__location.Relative_Location;
+            type l_entry = Schema_Tree_;
+        }
+        type D = {
+            readonly 'l location': D.l_location;
+            readonly 'l entry': D.l_entry;
+        };
+    }
+    type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+}
+export type Schemas_ = {
+    readonly 'l location': Schemas_.l_location;
+    readonly 'l dictionary': Schemas_.l_dictionary;
+};
+export declare namespace Schema_ {
+    type imports = Imports_;
+    type globals = Globals_;
+    type modules = Modules_;
+    namespace complexity {
+        type l_location = i__location.Relative_Location;
+        namespace l_state {
+            type constrained = Resolve_Logic_;
+            type unconstrained = null;
+        }
+        type l_state = readonly ['constrained', l_state.constrained] | readonly ['unconstrained', l_state.unconstrained];
+    }
+    type complexity = {
+        readonly 'l location': complexity.l_location;
+        readonly 'l state': complexity.l_state;
+    };
+}
+export type Schema_ = {
+    readonly 'imports': Schema_.imports;
+    readonly 'globals': Schema_.globals;
+    readonly 'modules': Schema_.modules;
+    readonly 'complexity': Schema_.complexity;
+};
+export declare namespace Imports_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_dictionary {
+        namespace D {
+            type l_location = i__location.Relative_Location;
+            namespace l_entry {
+                namespace schema_set_child {
+                    type l_location = i__location.Relative_Location;
+                    type l_reference = string;
+                }
+                type schema_set_child = {
+                    readonly 'l location': schema_set_child.l_location;
+                    readonly 'l reference': schema_set_child.l_reference;
+                };
+                type schema = null;
+            }
+            type l_entry = {
+                readonly 'schema set child': l_entry.schema_set_child;
+                readonly 'schema': l_entry.schema;
+            };
+        }
+        type D = {
+            readonly 'l location': D.l_location;
+            readonly 'l entry': D.l_entry;
+        };
+    }
+    type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+}
+export type Imports_ = {
+    readonly 'l location': Imports_.l_location;
+    readonly 'l dictionary': Imports_.l_dictionary;
+};
+export declare namespace Modules_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_dictionary {
+        namespace D {
+            type l_location = i__location.Relative_Location;
+            type l_entry = Module_;
+        }
+        type D = {
+            readonly 'l location': D.l_location;
+            readonly 'l entry': D.l_entry;
+        };
+    }
+    type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+}
+export type Modules_ = {
+    readonly 'l location': Modules_.l_location;
+    readonly 'l dictionary': Modules_.l_dictionary;
+};
+export declare namespace Globals_ {
+    namespace complexity {
+        type l_location = i__location.Relative_Location;
+        namespace l_state {
+            type constrained = null;
+            type unconstrained = null;
+        }
+        type l_state = readonly ['constrained', l_state.constrained] | readonly ['unconstrained', l_state.unconstrained];
+    }
+    type complexity = {
+        readonly 'l location': complexity.l_location;
+        readonly 'l state': complexity.l_state;
+    };
+    namespace text_types {
+        type l_location = i__location.Relative_Location;
+        namespace l_dictionary {
+            namespace D {
+                type l_location = i__location.Relative_Location;
+                type l_entry = Text_Type_;
+            }
+            type D = {
+                readonly 'l location': D.l_location;
+                readonly 'l entry': D.l_entry;
+            };
+        }
+        type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+    }
+    type text_types = {
+        readonly 'l location': text_types.l_location;
+        readonly 'l dictionary': text_types.l_dictionary;
+    };
+    namespace number_types {
+        type l_location = i__location.Relative_Location;
+        namespace l_dictionary {
+            namespace D {
+                type l_location = i__location.Relative_Location;
+                type l_entry = Number_Type_;
+            }
+            type D = {
+                readonly 'l location': D.l_location;
+                readonly 'l entry': D.l_entry;
+            };
+        }
+        type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+    }
+    type number_types = {
+        readonly 'l location': number_types.l_location;
+        readonly 'l dictionary': number_types.l_dictionary;
+    };
+}
+export type Globals_ = {
+    readonly 'complexity': Globals_.complexity;
+    readonly 'text types': Globals_.text_types;
+    readonly 'number types': Globals_.number_types;
+};
+export declare namespace Dictionary_ {
+    type value = Value_;
+}
+export type Dictionary_ = {
+    readonly 'value': Dictionary_.value;
+};
+export declare namespace Value_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_state {
+        type boolean_ = null;
+        namespace component {
+            namespace type_ {
+                type l_location = i__location.Relative_Location;
+                namespace l_state {
+                    namespace external {
+                        namespace import_ {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type import_ = {
+                            readonly 'l location': import_.l_location;
+                            readonly 'l reference': import_.l_reference;
+                        };
+                        namespace module_ {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type module_ = {
+                            readonly 'l location': module_.l_location;
+                            readonly 'l reference': module_.l_reference;
+                        };
+                    }
+                    type external = {
+                        readonly 'import': external.import_;
+                        readonly 'module': external.module_;
+                    };
+                    namespace internal {
+                        type l_location = i__location.Relative_Location;
+                        type l_reference = string;
+                    }
+                    type internal = {
+                        readonly 'l location': internal.l_location;
+                        readonly 'l reference': internal.l_reference;
+                    };
+                    namespace internal_acyclic {
+                        type l_location = i__location.Relative_Location;
+                        type l_reference = string;
+                    }
+                    type internal_acyclic = {
+                        readonly 'l location': internal_acyclic.l_location;
+                        readonly 'l reference': internal_acyclic.l_reference;
+                    };
+                }
+                type l_state = readonly ['external', l_state.external] | readonly ['internal', l_state.internal] | readonly ['internal acyclic', l_state.internal_acyclic];
+            }
+            type type_ = {
+                readonly 'l location': type_.l_location;
+                readonly 'l state': type_.l_state;
+            };
+            type results = Value_Results_;
+        }
+        type component = {
+            readonly 'type': component.type_;
+            readonly 'results': component.results;
+        };
+        type dictionary = Dictionary_;
+        type group = Group_;
+        namespace list {
+            type value = Value_;
+            type results = Value_Results_;
+        }
+        type list = {
+            readonly 'value': list.value;
+            readonly 'results': list.results;
+        };
+        type nothing = null;
+        namespace number_ {
+            type l_location = i__location.Relative_Location;
+            namespace l_state {
+                namespace global {
+                    type l_location = i__location.Relative_Location;
+                    type l_reference = string;
+                }
+                type global = {
+                    readonly 'l location': global.l_location;
+                    readonly 'l reference': global.l_reference;
+                };
+                type local = Number_Type_;
+            }
+            type l_state = readonly ['global', l_state.global] | readonly ['local', l_state.local];
+        }
+        type number_ = {
+            readonly 'l location': number_.l_location;
+            readonly 'l state': number_.l_state;
+        };
+        type optional = Value_;
+        namespace reference {
+            type referent = Value_Reference_;
+            namespace type_ {
+                type l_location = i__location.Relative_Location;
+                namespace l_state {
+                    type derived = null;
+                    namespace selected {
+                        type dictionary = null;
+                        namespace dependency {
+                            type l_location = i__location.Relative_Location;
+                            namespace l_state {
+                                type acyclic = null;
+                                type cyclic = null;
+                                type stack = null;
+                            }
+                            type l_state = readonly ['acyclic', l_state.acyclic] | readonly ['cyclic', l_state.cyclic] | readonly ['stack', l_state.stack];
+                        }
+                        type dependency = {
+                            readonly 'l location': dependency.l_location;
+                            readonly 'l state': dependency.l_state;
+                        };
+                    }
+                    type selected = {
+                        readonly 'dictionary': selected.dictionary;
+                        readonly 'dependency': selected.dependency;
+                    };
+                }
+                type l_state = readonly ['derived', l_state.derived] | readonly ['selected', l_state.selected];
+            }
+            type type_ = {
+                readonly 'l location': type_.l_location;
+                readonly 'l state': type_.l_state;
+            };
+        }
+        type reference = {
+            readonly 'referent': reference.referent;
+            readonly 'type': reference.type_;
+        };
+        namespace state {
+            namespace options {
+                type l_location = i__location.Relative_Location;
+                namespace l_dictionary {
+                    namespace D {
+                        type l_location = i__location.Relative_Location;
+                        namespace l_entry {
+                            type constraints = Option_Constraints_;
+                            namespace description {
+                                type O = string;
+                            }
+                            type description = _pi.Optional_Value<description.O>;
+                            type value = Value_;
+                        }
+                        type l_entry = {
+                            readonly 'constraints': l_entry.constraints;
+                            readonly 'description': l_entry.description;
+                            readonly 'value': l_entry.value;
+                        };
+                    }
+                    type D = {
+                        readonly 'l location': D.l_location;
+                        readonly 'l entry': D.l_entry;
+                    };
+                }
+                type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+            }
+            type options = {
+                readonly 'l location': options.l_location;
+                readonly 'l dictionary': options.l_dictionary;
+            };
+            type results = Value_Results_;
+        }
+        type state = {
+            readonly 'options': state.options;
+            readonly 'results': state.results;
+        };
+        namespace text {
+            type l_location = i__location.Relative_Location;
+            namespace l_state {
+                namespace global {
+                    type l_location = i__location.Relative_Location;
+                    type l_reference = string;
+                }
+                type global = {
+                    readonly 'l location': global.l_location;
+                    readonly 'l reference': global.l_reference;
+                };
+                type local = Text_Type_;
+            }
+            type l_state = readonly ['global', l_state.global] | readonly ['local', l_state.local];
+        }
+        type text = {
+            readonly 'l location': text.l_location;
+            readonly 'l state': text.l_state;
+        };
+    }
+    type l_state = readonly ['boolean', l_state.boolean_] | readonly ['component', l_state.component] | readonly ['dictionary', l_state.dictionary] | readonly ['group', l_state.group] | readonly ['list', l_state.list] | readonly ['nothing', l_state.nothing] | readonly ['number', l_state.number_] | readonly ['optional', l_state.optional] | readonly ['reference', l_state.reference] | readonly ['state', l_state.state] | readonly ['text', l_state.text];
+}
+export type Value_ = {
+    readonly 'l location': Value_.l_location;
+    readonly 'l state': Value_.l_state;
+};
+export declare namespace Signatures_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_dictionary {
+        namespace D {
+            type l_location = i__location.Relative_Location;
+            type l_entry = Signature_;
+        }
+        type D = {
+            readonly 'l location': D.l_location;
+            readonly 'l entry': D.l_entry;
+        };
+    }
+    type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+}
+export type Signatures_ = {
+    readonly 'l location': Signatures_.l_location;
+    readonly 'l dictionary': Signatures_.l_dictionary;
+};
+export declare namespace Signature_Parameters_ {
+    namespace modules {
+        type l_location = i__location.Relative_Location;
+        namespace l_dictionary {
+            namespace D {
+                type l_location = i__location.Relative_Location;
+                namespace l_entry {
+                    type module_ = Module_Reference_;
+                    type presence = Presence_;
+                }
+                type l_entry = {
+                    readonly 'module': l_entry.module_;
+                    readonly 'presence': l_entry.presence;
+                };
+            }
+            type D = {
+                readonly 'l location': D.l_location;
+                readonly 'l entry': D.l_entry;
+            };
+        }
+        type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+    }
+    type modules = {
+        readonly 'l location': modules.l_location;
+        readonly 'l dictionary': modules.l_dictionary;
+    };
+    namespace lookups {
+        type l_location = i__location.Relative_Location;
+        namespace l_dictionary {
+            namespace D {
+                type l_location = i__location.Relative_Location;
+                namespace l_entry {
+                    type referent = Module_Reference_;
+                    type dictionary = null;
+                    namespace type_ {
+                        type l_location = i__location.Relative_Location;
+                        namespace l_state {
+                            type cyclic = null;
+                            type acyclic = null;
+                            type stack = null;
+                        }
+                        type l_state = readonly ['cyclic', l_state.cyclic] | readonly ['acyclic', l_state.acyclic] | readonly ['stack', l_state.stack];
+                    }
+                    type type_ = {
+                        readonly 'l location': type_.l_location;
+                        readonly 'l state': type_.l_state;
+                    };
+                    type presence = Presence_;
+                }
+                type l_entry = {
+                    readonly 'referent': l_entry.referent;
+                    readonly 'dictionary': l_entry.dictionary;
+                    readonly 'type': l_entry.type_;
+                    readonly 'presence': l_entry.presence;
+                };
+            }
+            type D = {
+                readonly 'l location': D.l_location;
+                readonly 'l entry': D.l_entry;
+            };
+        }
+        type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+    }
+    type lookups = {
+        readonly 'l location': lookups.l_location;
+        readonly 'l dictionary': lookups.l_dictionary;
+    };
+}
+export type Signature_Parameters_ = {
+    readonly 'modules': Signature_Parameters_.modules;
+    readonly 'lookups': Signature_Parameters_.lookups;
+};
+export declare namespace Value_Resolver_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_state {
+        type boolean_ = null;
+        namespace component {
+            type definition = null;
+            namespace location {
+                type l_location = i__location.Relative_Location;
+                namespace l_state {
+                    namespace external {
+                        namespace import_ {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type import_ = {
+                            readonly 'l location': import_.l_location;
+                            readonly 'l reference': import_.l_reference;
+                        };
+                        namespace signature {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type signature = {
+                            readonly 'l location': signature.l_location;
+                            readonly 'l reference': signature.l_reference;
+                        };
+                    }
+                    type external = {
+                        readonly 'import': external.import_;
+                        readonly 'signature': external.signature;
+                    };
+                    namespace internal {
+                        type l_location = i__location.Relative_Location;
+                        type l_reference = string;
+                    }
+                    type internal = {
+                        readonly 'l location': internal.l_location;
+                        readonly 'l reference': internal.l_reference;
+                    };
+                }
+                type l_state = readonly ['external', l_state.external] | readonly ['internal', l_state.internal];
+            }
+            type location = {
+                readonly 'l location': location.l_location;
+                readonly 'l state': location.l_state;
+            };
+            type signature = null;
+            namespace arguments_ {
+                namespace O {
+                    namespace modules {
+                        namespace O {
+                            type l_location = i__location.Relative_Location;
+                            namespace l_dictionary {
+                                namespace D {
+                                    type l_location = i__location.Relative_Location;
+                                    namespace l_entry {
+                                        type l_location = i__location.Relative_Location;
+                                        namespace l_state {
+                                            type optional = Optional_Value_Initialization_;
+                                            type required = Guaranteed_Value_Selection_;
+                                            namespace parameter {
+                                                type l_location = i__location.Relative_Location;
+                                                type l_reference = string;
+                                            }
+                                            type parameter = {
+                                                readonly 'l location': parameter.l_location;
+                                                readonly 'l reference': parameter.l_reference;
+                                            };
+                                        }
+                                        type l_state = readonly ['optional', l_state.optional] | readonly ['required', l_state.required] | readonly ['parameter', l_state.parameter];
+                                    }
+                                    type l_entry = {
+                                        readonly 'l location': l_entry.l_location;
+                                        readonly 'l state': l_entry.l_state;
+                                    };
+                                }
+                                type D = {
+                                    readonly 'l location': D.l_location;
+                                    readonly 'l entry': D.l_entry;
+                                };
+                            }
+                            type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+                        }
+                        type O = {
+                            readonly 'l location': O.l_location;
+                            readonly 'l dictionary': O.l_dictionary;
+                        };
+                    }
+                    type modules = _pi.Optional_Value<modules.O>;
+                    namespace lookups {
+                        namespace O {
+                            type l_location = i__location.Relative_Location;
+                            namespace l_dictionary {
+                                namespace D {
+                                    type l_location = i__location.Relative_Location;
+                                    namespace l_entry {
+                                        type l_location = i__location.Relative_Location;
+                                        namespace l_state {
+                                            namespace stack {
+                                                type l_location = i__location.Relative_Location;
+                                                namespace l_state {
+                                                    type empty = null;
+                                                    namespace push {
+                                                        type stack = Lookup_Selection_;
+                                                        type item = Lookup_Selection_;
+                                                    }
+                                                    type push = {
+                                                        readonly 'stack': push.stack;
+                                                        readonly 'item': push.item;
+                                                    };
+                                                }
+                                                type l_state = readonly ['empty', l_state.empty] | readonly ['push', l_state.push];
+                                            }
+                                            type stack = {
+                                                readonly 'l location': stack.l_location;
+                                                readonly 'l state': stack.l_state;
+                                            };
+                                            namespace acyclic {
+                                                type l_location = i__location.Relative_Location;
+                                                namespace l_state {
+                                                    type not_set = null;
+                                                }
+                                                type l_state = readonly ['not set', l_state.not_set];
+                                            }
+                                            type acyclic = {
+                                                readonly 'l location': acyclic.l_location;
+                                                readonly 'l state': acyclic.l_state;
+                                            };
+                                            namespace cyclic {
+                                                type l_location = i__location.Relative_Location;
+                                                namespace l_state {
+                                                    type not_set = null;
+                                                }
+                                                type l_state = readonly ['not set', l_state.not_set];
+                                            }
+                                            type cyclic = {
+                                                readonly 'l location': cyclic.l_location;
+                                                readonly 'l state': cyclic.l_state;
+                                            };
+                                            type selection = Lookup_Selection_;
+                                        }
+                                        type l_state = readonly ['stack', l_state.stack] | readonly ['acyclic', l_state.acyclic] | readonly ['cyclic', l_state.cyclic] | readonly ['selection', l_state.selection];
+                                    }
+                                    type l_entry = {
+                                        readonly 'l location': l_entry.l_location;
+                                        readonly 'l state': l_entry.l_state;
+                                    };
+                                }
+                                type D = {
+                                    readonly 'l location': D.l_location;
+                                    readonly 'l entry': D.l_entry;
+                                };
+                            }
+                            type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+                        }
+                        type O = {
+                            readonly 'l location': O.l_location;
+                            readonly 'l dictionary': O.l_dictionary;
+                        };
+                    }
+                    type lookups = _pi.Optional_Value<lookups.O>;
+                }
+                type O = {
+                    readonly 'modules': O.modules;
+                    readonly 'lookups': O.lookups;
+                };
+            }
+            type arguments_ = _pi.Optional_Value<arguments_.O>;
+            type constraints = Value_Constraint_Resolvers_;
+        }
+        type component = {
+            readonly 'definition': component.definition;
+            readonly 'location': component.location;
+            readonly 'signature': component.signature;
+            readonly 'arguments': component.arguments_;
+            readonly 'constraints': component.constraints;
+        };
+        namespace dictionary {
+            type definition = null;
+            type resolver = Value_Resolver_;
+            namespace benchmark {
+                type O = Benchmark_;
+            }
+            type benchmark = _pi.Optional_Value<benchmark.O>;
+        }
+        type dictionary = {
+            readonly 'definition': dictionary.definition;
+            readonly 'resolver': dictionary.resolver;
+            readonly 'benchmark': dictionary.benchmark;
+        };
+        type group = Value_Resolver_Group_;
+        namespace list {
+            type definition = null;
+            type resolver = Value_Resolver_;
+            namespace result {
+                type O = Value_Resolver_List_Result_;
+            }
+            type result = _pi.Optional_Value<result.O>;
+        }
+        type list = {
+            readonly 'definition': list.definition;
+            readonly 'resolver': list.resolver;
+            readonly 'result': list.result;
+        };
+        type nothing = null;
+        type number_ = null;
+        namespace optional {
+            type constraints = Option_Constraint_Resolvers_;
+            type resolver = Value_Resolver_;
+        }
+        type optional = {
+            readonly 'constraints': optional.constraints;
+            readonly 'resolver': optional.resolver;
+        };
+        namespace reference {
+            type definition = null;
+            namespace type_ {
+                type l_location = i__location.Relative_Location;
+                namespace l_state {
+                    namespace derived {
+                        type value = Guaranteed_Value_Selection_;
+                    }
+                    type derived = {
+                        readonly 'value': derived.value;
+                    };
+                    namespace selected {
+                        type definition = null;
+                        type lookup = Lookup_Selection_;
+                        type constraints = Value_Constraint_Resolvers_;
+                    }
+                    type selected = {
+                        readonly 'definition': selected.definition;
+                        readonly 'lookup': selected.lookup;
+                        readonly 'constraints': selected.constraints;
+                    };
+                }
+                type l_state = readonly ['derived', l_state.derived] | readonly ['selected', l_state.selected];
+            }
+            type type_ = {
+                readonly 'l location': type_.l_location;
+                readonly 'l state': type_.l_state;
+            };
+        }
+        type reference = {
+            readonly 'definition': reference.definition;
+            readonly 'type': reference.type_;
+        };
+        namespace state {
+            type definition = null;
+            namespace states {
+                type l_location = i__location.Relative_Location;
+                namespace l_dictionary {
+                    namespace D {
+                        type l_location = i__location.Relative_Location;
+                        namespace l_entry {
+                            type constraints = Option_Constraint_Resolvers_;
+                            type resolver = Value_Resolver_;
+                        }
+                        type l_entry = {
+                            readonly 'constraints': l_entry.constraints;
+                            readonly 'resolver': l_entry.resolver;
+                        };
+                    }
+                    type D = {
+                        readonly 'l location': D.l_location;
+                        readonly 'l entry': D.l_entry;
+                    };
+                }
+                type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+            }
+            type states = {
+                readonly 'l location': states.l_location;
+                readonly 'l dictionary': states.l_dictionary;
+            };
+        }
+        type state = {
+            readonly 'definition': state.definition;
+            readonly 'states': state.states;
+        };
+        type text = null;
+    }
+    type l_state = readonly ['boolean', l_state.boolean_] | readonly ['component', l_state.component] | readonly ['dictionary', l_state.dictionary] | readonly ['group', l_state.group] | readonly ['list', l_state.list] | readonly ['nothing', l_state.nothing] | readonly ['number', l_state.number_] | readonly ['optional', l_state.optional] | readonly ['reference', l_state.reference] | readonly ['state', l_state.state] | readonly ['text', l_state.text];
+}
+export type Value_Resolver_ = {
+    readonly 'l location': Value_Resolver_.l_location;
+    readonly 'l state': Value_Resolver_.l_state;
+};
+export declare namespace Module_Specification_ {
+    type schema = Schema_Tree_;
+    namespace schema_path {
+        type l_location = i__location.Relative_Location;
+        namespace l_list {
+            namespace L {
+                type l_location = i__location.Relative_Location;
+                type l_item = string;
+            }
+            type L = {
+                readonly 'l location': L.l_location;
+                readonly 'l item': L.l_item;
+            };
+        }
+        type l_list = _pi.List<l_list.L>;
+    }
+    type schema_path = {
+        readonly 'l location': schema_path.l_location;
+        readonly 'l list': schema_path.l_list;
+    };
+    type module_ = string;
+}
+export type Module_Specification_ = {
+    readonly 'schema': Module_Specification_.schema;
+    readonly 'schema path': Module_Specification_.schema_path;
+    readonly 'module': Module_Specification_.module_;
+};
+export declare namespace Schema_Tree_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_state {
+        type schema = Schema_;
+        type set_ = Schemas_;
+    }
+    type l_state = readonly ['schema', l_state.schema] | readonly ['set', l_state.set_];
+}
+export type Schema_Tree_ = {
+    readonly 'l location': Schema_Tree_.l_location;
+    readonly 'l state': Schema_Tree_.l_state;
+};
+export declare namespace Resolve_Logic_ {
+    namespace signatures {
+        type signatures = Signatures_;
+    }
+    type signatures = {
+        readonly 'signatures': signatures.signatures;
+    };
+    type resolvers = Module_Resolvers_;
+}
+export type Resolve_Logic_ = {
+    readonly 'signatures': Resolve_Logic_.signatures;
+    readonly 'resolvers': Resolve_Logic_.resolvers;
+};
+export declare namespace Text_Type_ {
+    namespace type_ {
+        type l_location = i__location.Relative_Location;
+        namespace l_state {
+            type multi_line = null;
+            type single_line = null;
+        }
+        type l_state = readonly ['multi line', l_state.multi_line] | readonly ['single line', l_state.single_line];
+    }
+    type type_ = {
+        readonly 'l location': type_.l_location;
+        readonly 'l state': type_.l_state;
+    };
+}
+export type Text_Type_ = {
+    readonly 'type': Text_Type_.type_;
+};
+export declare namespace Number_Type_ {
+    namespace precision {
+        type l_location = i__location.Relative_Location;
+        namespace l_state {
+            namespace approximation {
+                type significant_digits = number;
+            }
+            type approximation = {
+                readonly 'significant digits': approximation.significant_digits;
+            };
+            namespace exact {
+                namespace decimal_separator_offset {
+                    type O = number;
+                }
+                type decimal_separator_offset = _pi.Optional_Value<decimal_separator_offset.O>;
+                namespace type_ {
+                    type l_location = i__location.Relative_Location;
+                    namespace l_state {
+                        type integer = null;
+                        type natural = null;
+                        type positive_natural = null;
+                    }
+                    type l_state = readonly ['integer', l_state.integer] | readonly ['natural', l_state.natural] | readonly ['positive natural', l_state.positive_natural];
+                }
+                type type_ = {
+                    readonly 'l location': type_.l_location;
+                    readonly 'l state': type_.l_state;
+                };
+            }
+            type exact = {
+                readonly 'decimal separator offset': exact.decimal_separator_offset;
+                readonly 'type': exact.type_;
+            };
+        }
+        type l_state = readonly ['approximation', l_state.approximation] | readonly ['exact', l_state.exact];
+    }
+    type precision = {
+        readonly 'l location': precision.l_location;
+        readonly 'l state': precision.l_state;
+    };
+}
+export type Number_Type_ = {
+    readonly 'precision': Number_Type_.precision;
+};
+export declare namespace Module_ {
+    type root_value = Value_;
+}
+export type Module_ = {
+    readonly 'root value': Module_.root_value;
+};
+export declare namespace Presence_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_state {
+        type optional = null;
+        type required = null;
+    }
+    type l_state = readonly ['optional', l_state.optional] | readonly ['required', l_state.required];
+}
+export type Presence_ = {
+    readonly 'l location': Presence_.l_location;
+    readonly 'l state': Presence_.l_state;
+};
+export declare namespace Module_Resolvers_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_dictionary {
+        namespace D {
+            type l_location = i__location.Relative_Location;
+            namespace l_entry {
+                type signature = null;
+                type root_value_resolver = Value_Resolver_;
+            }
+            type l_entry = {
+                readonly 'signature': l_entry.signature;
+                readonly 'root value resolver': l_entry.root_value_resolver;
+            };
+        }
+        type D = {
+            readonly 'l location': D.l_location;
+            readonly 'l entry': D.l_entry;
+        };
+    }
+    type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+}
+export type Module_Resolvers_ = {
+    readonly 'l location': Module_Resolvers_.l_location;
+    readonly 'l dictionary': Module_Resolvers_.l_dictionary;
+};
+export declare namespace Benchmark_ {
+    type selection = Guaranteed_Value_Selection_;
+    type resulting_dictionary = null;
+    type dense = boolean;
+}
+export type Benchmark_ = {
+    readonly 'selection': Benchmark_.selection;
+    readonly 'resulting dictionary': Benchmark_.resulting_dictionary;
+    readonly 'dense': Benchmark_.dense;
+};
+export declare namespace Group_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_dictionary {
+        namespace D {
+            type l_location = i__location.Relative_Location;
+            namespace l_entry {
+                namespace description {
+                    type O = string;
+                }
+                type description = _pi.Optional_Value<description.O>;
+                type value = Value_;
+            }
+            type l_entry = {
+                readonly 'description': l_entry.description;
+                readonly 'value': l_entry.value;
+            };
+        }
+        type D = {
+            readonly 'l location': D.l_location;
+            readonly 'l entry': D.l_entry;
+        };
+    }
+    type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+}
+export type Group_ = {
+    readonly 'l location': Group_.l_location;
+    readonly 'l dictionary': Group_.l_dictionary;
+};
+export declare namespace Value_Reference_ {
+    type module_ = Module_Reference_;
+    type path = Value_Path_;
+}
+export type Value_Reference_ = {
+    readonly 'module': Value_Reference_.module_;
+    readonly 'path': Value_Reference_.path;
+};
+export declare namespace Value_Path_ {
+    namespace tail {
+        type l_location = i__location.Relative_Location;
+        namespace l_list {
+            namespace L {
+                type l_location = i__location.Relative_Location;
+                namespace l_item {
+                    type l_location = i__location.Relative_Location;
+                    namespace l_state {
+                        type dictionary = null;
+                        namespace group {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type group = {
+                            readonly 'l location': group.l_location;
+                            readonly 'l reference': group.l_reference;
+                        };
+                        type list = null;
+                        type optional = null;
+                        namespace state {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type state = {
+                            readonly 'l location': state.l_location;
+                            readonly 'l reference': state.l_reference;
+                        };
+                    }
+                    type l_state = readonly ['dictionary', l_state.dictionary] | readonly ['group', l_state.group] | readonly ['list', l_state.list] | readonly ['optional', l_state.optional] | readonly ['state', l_state.state];
+                }
+                type l_item = {
+                    readonly 'l location': l_item.l_location;
+                    readonly 'l state': l_item.l_state;
+                };
+            }
+            type L = {
+                readonly 'l location': L.l_location;
+                readonly 'l item': L.l_item;
+            };
+        }
+        type l_list = _pi.List<l_list.L>;
+    }
+    type tail = {
+        readonly 'l location': tail.l_location;
+        readonly 'l list': tail.l_list;
+    };
+    type resulting_node = null;
+}
+export type Value_Path_ = {
+    readonly 'tail': Value_Path_.tail;
+    readonly 'resulting node': Value_Path_.resulting_node;
+};
+export declare namespace Module_Reference_ {
+    namespace location {
+        type l_location = i__location.Relative_Location;
+        namespace l_state {
+            namespace internal {
+                type l_location = i__location.Relative_Location;
+                type l_reference = string;
+            }
+            type internal = {
+                readonly 'l location': internal.l_location;
+                readonly 'l reference': internal.l_reference;
+            };
+            namespace external {
+                namespace import_ {
+                    type l_location = i__location.Relative_Location;
+                    type l_reference = string;
+                }
+                type import_ = {
+                    readonly 'l location': import_.l_location;
+                    readonly 'l reference': import_.l_reference;
+                };
+                namespace module_ {
+                    type l_location = i__location.Relative_Location;
+                    type l_reference = string;
+                }
+                type module_ = {
+                    readonly 'l location': module_.l_location;
+                    readonly 'l reference': module_.l_reference;
+                };
+            }
+            type external = {
+                readonly 'import': external.import_;
+                readonly 'module': external.module_;
+            };
+        }
+        type l_state = readonly ['internal', l_state.internal] | readonly ['external', l_state.external];
+    }
+    type location = {
+        readonly 'l location': location.l_location;
+        readonly 'l state': location.l_state;
+    };
+    type resulting_module = null;
+}
+export type Module_Reference_ = {
+    readonly 'location': Module_Reference_.location;
+    readonly 'resulting module': Module_Reference_.resulting_module;
+};
+export declare namespace Signature_ {
+    type module_ = null;
+    namespace parameters {
+        type l_location = i__location.Relative_Location;
+        namespace l_state {
+            type local = Signature_Parameters_;
+            namespace same_as {
+                type l_location = i__location.Relative_Location;
+                type l_reference = string;
+            }
+            type same_as = {
+                readonly 'l location': same_as.l_location;
+                readonly 'l reference': same_as.l_reference;
+            };
+        }
+        type l_state = readonly ['local', l_state.local] | readonly ['same as', l_state.same_as];
+    }
+    type parameters = {
+        readonly 'l location': parameters.l_location;
+        readonly 'l state': parameters.l_state;
+    };
+    type resolved_parameters = null;
+}
+export type Signature_ = {
+    readonly 'module': Signature_.module_;
+    readonly 'parameters': Signature_.parameters;
+    readonly 'resolved parameters': Signature_.resolved_parameters;
+};
+export declare namespace Relative_Value_Selection_ {
+    namespace path {
+        type l_location = i__location.Relative_Location;
+        namespace l_list {
+            namespace L {
+                type l_location = i__location.Relative_Location;
+                namespace l_item {
+                    type l_location = i__location.Relative_Location;
+                    namespace l_state {
+                        type component = null;
+                        namespace group {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type group = {
+                            readonly 'l location': group.l_location;
+                            readonly 'l reference': group.l_reference;
+                        };
+                        namespace reference {
+                            type definition = null;
+                        }
+                        type reference = {
+                            readonly 'definition': reference.definition;
+                        };
+                    }
+                    type l_state = readonly ['component', l_state.component] | readonly ['group', l_state.group] | readonly ['reference', l_state.reference];
+                }
+                type l_item = {
+                    readonly 'l location': l_item.l_location;
+                    readonly 'l state': l_item.l_state;
+                };
+            }
+            type L = {
+                readonly 'l location': L.l_location;
+                readonly 'l item': L.l_item;
+            };
+        }
+        type l_list = _pi.List<l_list.L>;
+    }
+    type path = {
+        readonly 'l location': path.l_location;
+        readonly 'l list': path.l_list;
+    };
+    type resulting_node = null;
+}
+export type Relative_Value_Selection_ = {
+    readonly 'path': Relative_Value_Selection_.path;
+    readonly 'resulting node': Relative_Value_Selection_.resulting_node;
+};
+export declare namespace Lookup_Selection_ {
+    namespace type_ {
+        type l_location = i__location.Relative_Location;
+        namespace l_state {
+            namespace acyclic {
+                type l_location = i__location.Relative_Location;
+                namespace l_state {
+                    type siblings = null;
+                    namespace resolved_dictionary {
+                        type selection = Guaranteed_Value_Selection_;
+                        type selected_dictionary = null;
+                    }
+                    type resolved_dictionary = {
+                        readonly 'selection': resolved_dictionary.selection;
+                        readonly 'selected dictionary': resolved_dictionary.selected_dictionary;
+                    };
+                }
+                type l_state = readonly ['siblings', l_state.siblings] | readonly ['resolved dictionary', l_state.resolved_dictionary];
+            }
+            type acyclic = {
+                readonly 'l location': acyclic.l_location;
+                readonly 'l state': acyclic.l_state;
+            };
+            namespace cyclic {
+                type l_location = i__location.Relative_Location;
+                namespace l_state {
+                    type siblings = null;
+                }
+                type l_state = readonly ['siblings', l_state.siblings];
+            }
+            type cyclic = {
+                readonly 'l location': cyclic.l_location;
+                readonly 'l state': cyclic.l_state;
+            };
+            namespace parameter {
+                type l_location = i__location.Relative_Location;
+                type l_reference = string;
+            }
+            type parameter = {
+                readonly 'l location': parameter.l_location;
+                readonly 'l reference': parameter.l_reference;
+            };
+        }
+        type l_state = readonly ['acyclic', l_state.acyclic] | readonly ['cyclic', l_state.cyclic] | readonly ['parameter', l_state.parameter];
+    }
+    type type_ = {
+        readonly 'l location': type_.l_location;
+        readonly 'l state': type_.l_state;
+    };
+    type resulting_dictionary = null;
+}
+export type Lookup_Selection_ = {
+    readonly 'type': Lookup_Selection_.type_;
+    readonly 'resulting dictionary': Lookup_Selection_.resulting_dictionary;
+};
+export declare namespace Constraint_ {
+    type selection = Relative_Value_Selection_;
+    namespace type_ {
+        type l_location = i__location.Relative_Location;
+        namespace l_state {
+            namespace state {
+                type selected_state = null;
+                namespace option {
+                    type l_location = i__location.Relative_Location;
+                    type l_reference = string;
+                }
+                type option = {
+                    readonly 'l location': option.l_location;
+                    readonly 'l reference': option.l_reference;
+                };
+            }
+            type state = {
+                readonly 'selected state': state.selected_state;
+                readonly 'option': state.option;
+            };
+            namespace optional_value {
+                type selected_optional_value = null;
+            }
+            type optional_value = {
+                readonly 'selected optional value': optional_value.selected_optional_value;
+            };
+        }
+        type l_state = readonly ['state', l_state.state] | readonly ['optional value', l_state.optional_value];
+    }
+    type type_ = {
+        readonly 'l location': type_.l_location;
+        readonly 'l state': type_.l_state;
+    };
+}
+export type Constraint_ = {
+    readonly 'selection': Constraint_.selection;
+    readonly 'type': Constraint_.type_;
+};
+export declare namespace Option_Constraint_Resolvers_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_dictionary {
+        namespace D {
+            type l_location = i__location.Relative_Location;
+            namespace l_entry {
+                type l_location = i__location.Relative_Location;
+                namespace l_state {
+                    namespace state {
+                        type selection = Guaranteed_Value_Selection_;
+                        type selected_state = null;
+                        namespace option {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type option = {
+                            readonly 'l location': option.l_location;
+                            readonly 'l reference': option.l_reference;
+                        };
+                    }
+                    type state = {
+                        readonly 'selection': state.selection;
+                        readonly 'selected state': state.selected_state;
+                        readonly 'option': state.option;
+                    };
+                    type assert_is_set = Possible_Value_Selection_;
+                }
+                type l_state = readonly ['state', l_state.state] | readonly ['assert is set', l_state.assert_is_set];
+            }
+            type l_entry = {
+                readonly 'l location': l_entry.l_location;
+                readonly 'l state': l_entry.l_state;
+            };
+        }
+        type D = {
+            readonly 'l location': D.l_location;
+            readonly 'l entry': D.l_entry;
+        };
+    }
+    type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+}
+export type Option_Constraint_Resolvers_ = {
+    readonly 'l location': Option_Constraint_Resolvers_.l_location;
+    readonly 'l dictionary': Option_Constraint_Resolvers_.l_dictionary;
+};
+export declare namespace Value_Constraint_Resolvers_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_dictionary {
+        namespace D {
+            type l_location = i__location.Relative_Location;
+            type l_entry = Value_Constraint_Resolver_;
+        }
+        type D = {
+            readonly 'l location': D.l_location;
+            readonly 'l entry': D.l_entry;
+        };
+    }
+    type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+}
+export type Value_Constraint_Resolvers_ = {
+    readonly 'l location': Value_Constraint_Resolvers_.l_location;
+    readonly 'l dictionary': Value_Constraint_Resolvers_.l_dictionary;
+};
+export declare namespace Reference_To_Value_Constraint_Resolver_ {
+    type l_location = i__location.Relative_Location;
+    type l_reference = string;
+}
+export type Reference_To_Value_Constraint_Resolver_ = {
+    readonly 'l location': Reference_To_Value_Constraint_Resolver_.l_location;
+    readonly 'l reference': Reference_To_Value_Constraint_Resolver_.l_reference;
+};
+export declare namespace Value_Constraint_Resolver_ {
+    namespace start {
+        type l_location = i__location.Relative_Location;
+        namespace l_state {
+            type property = null;
+            type sibling = Reference_To_Value_Constraint_Resolver_;
+        }
+        type l_state = readonly ['property', l_state.property] | readonly ['sibling', l_state.sibling];
+    }
+    type start = {
+        readonly 'l location': start.l_location;
+        readonly 'l state': start.l_state;
+    };
+    type constraint = Constraint_;
+}
+export type Value_Constraint_Resolver_ = {
+    readonly 'start': Value_Constraint_Resolver_.start;
+    readonly 'constraint': Value_Constraint_Resolver_.constraint;
+};
+export declare namespace Optional_Value_Initialization_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_state {
+        type not_set = null;
+        type set_ = Guaranteed_Value_Selection_;
+        type selection = Possible_Value_Selection_;
+    }
+    type l_state = readonly ['not set', l_state.not_set] | readonly ['set', l_state.set_] | readonly ['selection', l_state.selection];
+}
+export type Optional_Value_Initialization_ = {
+    readonly 'l location': Optional_Value_Initialization_.l_location;
+    readonly 'l state': Optional_Value_Initialization_.l_state;
+};
+export declare namespace Value_Resolver_Group_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_dictionary {
+        namespace D {
+            type l_location = i__location.Relative_Location;
+            namespace l_entry {
+                type definition = null;
+                type resolver = Value_Resolver_;
+            }
+            type l_entry = {
+                readonly 'definition': l_entry.definition;
+                readonly 'resolver': l_entry.resolver;
+            };
+        }
+        type D = {
+            readonly 'l location': D.l_location;
+            readonly 'l entry': D.l_entry;
+        };
+    }
+    type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+}
+export type Value_Resolver_Group_ = {
+    readonly 'l location': Value_Resolver_Group_.l_location;
+    readonly 'l dictionary': Value_Resolver_Group_.l_dictionary;
+};
+export type Value_Resolver_List_Result_ = Module_Reference_;
+export declare namespace Value_Results_ {
+    namespace O {
+        type l_location = i__location.Relative_Location;
+        namespace l_dictionary {
+            namespace D {
+                type l_location = i__location.Relative_Location;
+                type l_entry = Value_Reference_;
+            }
+            type D = {
+                readonly 'l location': D.l_location;
+                readonly 'l entry': D.l_entry;
+            };
+        }
+        type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+    }
+    type O = {
+        readonly 'l location': O.l_location;
+        readonly 'l dictionary': O.l_dictionary;
+    };
+}
+export type Value_Results_ = _pi.Optional_Value<Value_Results_.O>;
+export declare namespace Option_Constraints_ {
+    namespace O {
+        type l_location = i__location.Relative_Location;
+        namespace l_dictionary {
+            namespace D {
+                type l_location = i__location.Relative_Location;
+                type l_entry = Value_Reference_;
+            }
+            type D = {
+                readonly 'l location': D.l_location;
+                readonly 'l entry': D.l_entry;
+            };
+        }
+        type l_dictionary = _pi.Dictionary<l_dictionary.D>;
+    }
+    type O = {
+        readonly 'l location': O.l_location;
+        readonly 'l dictionary': O.l_dictionary;
+    };
+}
+export type Option_Constraints_ = _pi.Optional_Value<Option_Constraints_.O>;
+export declare namespace Guaranteed_Value_Selection_ {
+    namespace start {
+        type l_location = i__location.Relative_Location;
+        namespace l_state {
+            namespace sibling {
+                type l_location = i__location.Relative_Location;
+                type l_reference = string;
+            }
+            type sibling = {
+                readonly 'l location': sibling.l_location;
+                readonly 'l reference': sibling.l_reference;
+            };
+            namespace parent_sibling {
+                type l_location = i__location.Relative_Location;
+                type l_reference = string;
+            }
+            type parent_sibling = {
+                readonly 'l location': parent_sibling.l_location;
+                readonly 'l reference': parent_sibling.l_reference;
+            };
+            namespace option_constraint {
+                type l_location = i__location.Relative_Location;
+                type l_reference = string;
+            }
+            type option_constraint = {
+                readonly 'l location': option_constraint.l_location;
+                readonly 'l reference': option_constraint.l_reference;
+            };
+            type list_cursor = null;
+            type linked_entry = null;
+            namespace constraint {
+                type l_location = i__location.Relative_Location;
+                namespace l_state {
+                    namespace component {
+                        namespace property {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type property = {
+                            readonly 'l location': property.l_location;
+                            readonly 'l reference': property.l_reference;
+                        };
+                        namespace constraint {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type constraint = {
+                            readonly 'l location': constraint.l_location;
+                            readonly 'l reference': constraint.l_reference;
+                        };
+                    }
+                    type component = {
+                        readonly 'property': component.property;
+                        readonly 'constraint': component.constraint;
+                    };
+                    namespace reference {
+                        namespace property {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type property = {
+                            readonly 'l location': property.l_location;
+                            readonly 'l reference': property.l_reference;
+                        };
+                        namespace constraint {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type constraint = {
+                            readonly 'l location': constraint.l_location;
+                            readonly 'l reference': constraint.l_reference;
+                        };
+                    }
+                    type reference = {
+                        readonly 'property': reference.property;
+                        readonly 'constraint': reference.constraint;
+                    };
+                }
+                type l_state = readonly ['component', l_state.component] | readonly ['reference', l_state.reference];
+            }
+            type constraint = {
+                readonly 'l location': constraint.l_location;
+                readonly 'l state': constraint.l_state;
+            };
+            namespace parameter {
+                type l_location = i__location.Relative_Location;
+                type l_reference = string;
+            }
+            type parameter = {
+                readonly 'l location': parameter.l_location;
+                readonly 'l reference': parameter.l_reference;
+            };
+            namespace result {
+                type l_location = i__location.Relative_Location;
+                namespace l_state {
+                    namespace list {
+                        namespace property {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type property = {
+                            readonly 'l location': property.l_location;
+                            readonly 'l reference': property.l_reference;
+                        };
+                        type list_result = null;
+                    }
+                    type list = {
+                        readonly 'property': list.property;
+                        readonly 'list result': list.list_result;
+                    };
+                    namespace state {
+                        namespace property {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type property = {
+                            readonly 'l location': property.l_location;
+                            readonly 'l reference': property.l_reference;
+                        };
+                        type state = null;
+                        type result = Module_Reference_;
+                    }
+                    type state = {
+                        readonly 'property': state.property;
+                        readonly 'state': state.state;
+                        readonly 'result': state.result;
+                    };
+                    namespace optional_value {
+                        namespace property {
+                            type l_location = i__location.Relative_Location;
+                            type l_reference = string;
+                        }
+                        type property = {
+                            readonly 'l location': property.l_location;
+                            readonly 'l reference': property.l_reference;
+                        };
+                        type optional_value = null;
+                        type result = Module_Reference_;
+                    }
+                    type optional_value = {
+                        readonly 'property': optional_value.property;
+                        readonly 'optional value': optional_value.optional_value;
+                        readonly 'result': optional_value.result;
+                    };
+                }
+                type l_state = readonly ['list', l_state.list] | readonly ['state', l_state.state] | readonly ['optional value', l_state.optional_value];
+            }
+            type result = {
+                readonly 'l location': result.l_location;
+                readonly 'l state': result.l_state;
+            };
+        }
+        type l_state = readonly ['sibling', l_state.sibling] | readonly ['parent sibling', l_state.parent_sibling] | readonly ['option constraint', l_state.option_constraint] | readonly ['list cursor', l_state.list_cursor] | readonly ['linked entry', l_state.linked_entry] | readonly ['constraint', l_state.constraint] | readonly ['parameter', l_state.parameter] | readonly ['result', l_state.result];
+    }
+    type start = {
+        readonly 'l location': start.l_location;
+        readonly 'l state': start.l_state;
+    };
+    type tail = Relative_Value_Selection_;
+    type resulting_node = null;
+}
+export type Guaranteed_Value_Selection_ = {
+    readonly 'start': Guaranteed_Value_Selection_.start;
+    readonly 'tail': Guaranteed_Value_Selection_.tail;
+    readonly 'resulting node': Guaranteed_Value_Selection_.resulting_node;
+};
+export declare namespace Possible_Value_Selection_ {
+    type l_location = i__location.Relative_Location;
+    namespace l_state {
+        namespace parameter {
+            type l_location = i__location.Relative_Location;
+            type l_reference = string;
+        }
+        type parameter = {
+            readonly 'l location': parameter.l_location;
+            readonly 'l reference': parameter.l_reference;
+        };
+        namespace result {
+            type l_location = i__location.Relative_Location;
+            namespace l_state {
+                namespace state {
+                    namespace property {
+                        type l_location = i__location.Relative_Location;
+                        type l_reference = string;
+                    }
+                    type property = {
+                        readonly 'l location': property.l_location;
+                        readonly 'l reference': property.l_reference;
+                    };
+                    type state = null;
+                    type result = Module_Reference_;
+                }
+                type state = {
+                    readonly 'property': state.property;
+                    readonly 'state': state.state;
+                    readonly 'result': state.result;
+                };
+                namespace optional_value {
+                    namespace property {
+                        type l_location = i__location.Relative_Location;
+                        type l_reference = string;
+                    }
+                    type property = {
+                        readonly 'l location': property.l_location;
+                        readonly 'l reference': property.l_reference;
+                    };
+                    type optional_value = null;
+                    type result = Module_Reference_;
+                }
+                type optional_value = {
+                    readonly 'property': optional_value.property;
+                    readonly 'optional value': optional_value.optional_value;
+                    readonly 'result': optional_value.result;
+                };
+            }
+            type l_state = readonly ['state', l_state.state] | readonly ['optional value', l_state.optional_value];
+        }
+        type result = {
+            readonly 'l location': result.l_location;
+            readonly 'l state': result.l_state;
+        };
+    }
+    type l_state = readonly ['parameter', l_state.parameter] | readonly ['result', l_state.result];
+}
+export type Possible_Value_Selection_ = {
+    readonly 'l location': Possible_Value_Selection_.l_location;
+    readonly 'l state': Possible_Value_Selection_.l_state;
+};
+export { Schemas_ as Schemas, Schema_ as Schema, Imports_ as Imports, Modules_ as Modules, Globals_ as Globals, Dictionary_ as Dictionary, Value_ as Value, Signatures_ as Signatures, Signature_Parameters_ as Signature_Parameters, Value_Resolver_ as Value_Resolver, Module_Specification_ as Module_Specification, Schema_Tree_ as Schema_Tree, Resolve_Logic_ as Resolve_Logic, Text_Type_ as Text_Type, Number_Type_ as Number_Type, Module_ as Module, Presence_ as Presence, Module_Resolvers_ as Module_Resolvers, Benchmark_ as Benchmark, Group_ as Group, Value_Reference_ as Value_Reference, Value_Path_ as Value_Path, Module_Reference_ as Module_Reference, Signature_ as Signature, Relative_Value_Selection_ as Relative_Value_Selection, Lookup_Selection_ as Lookup_Selection, Constraint_ as Constraint, Option_Constraint_Resolvers_ as Option_Constraint_Resolvers, Value_Constraint_Resolvers_ as Value_Constraint_Resolvers, Reference_To_Value_Constraint_Resolver_ as Reference_To_Value_Constraint_Resolver, Value_Constraint_Resolver_ as Value_Constraint_Resolver, Optional_Value_Initialization_ as Optional_Value_Initialization, Value_Resolver_Group_ as Value_Resolver_Group, Value_Resolver_List_Result_ as Value_Resolver_List_Result, Value_Results_ as Value_Results, Option_Constraints_ as Option_Constraints, Guaranteed_Value_Selection_ as Guaranteed_Value_Selection, Possible_Value_Selection_ as Possible_Value_Selection, };