pareto-liana 0.0.1 → 0.0.3

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

@@ -0,0 +1,1093 @@
+import * as _pi from "pareto-core/dist/interface";
+export declare namespace Schemas_ {
+    type D = Schema_Tree_;
+}
+export type Schemas_ = _pi.Dictionary<Schemas_.D>;
+export declare namespace Schema_ {
+    type imports = Imports_;
+    type globals = Globals_;
+    type modules = Modules_;
+    namespace complexity {
+        type constrained = Resolve_Logic_;
+        type unconstrained = null;
+    }
+    type complexity = readonly ['constrained', complexity.constrained] | readonly ['unconstrained', complexity.unconstrained];
+}
+export type Schema_ = {
+    readonly 'imports': Schema_.imports;
+    readonly 'globals': Schema_.globals;
+    readonly 'modules': Schema_.modules;
+    readonly 'complexity': Schema_.complexity;
+};
+export declare namespace Imports_ {
+    namespace D {
+        namespace schema_set_child {
+            type l_entry = Schemas_.D;
+            type l_id = string;
+            type l_up_steps = number;
+        }
+        type schema_set_child = {
+            readonly 'l entry': schema_set_child.l_entry;
+            readonly 'l id': schema_set_child.l_id;
+            readonly 'l up steps': schema_set_child.l_up_steps;
+        };
+        type schema = Schema_;
+    }
+    type D = {
+        readonly 'schema set child': D.schema_set_child;
+        readonly 'schema': D.schema;
+    };
+}
+export type Imports_ = _pi.Dictionary<Imports_.D>;
+export declare namespace Modules_ {
+    type D = Module_;
+}
+export type Modules_ = _pi.Dictionary<Modules_.D>;
+export declare namespace Globals_ {
+    namespace complexity {
+        type constrained = null;
+        type unconstrained = null;
+    }
+    type complexity = readonly ['constrained', complexity.constrained] | readonly ['unconstrained', complexity.unconstrained];
+    namespace text_types {
+        type D = Text_Type_;
+    }
+    type text_types = _pi.Dictionary<text_types.D>;
+    namespace number_types {
+        type D = Number_Type_;
+    }
+    type number_types = _pi.Dictionary<number_types.D>;
+}
+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 boolean_ = null;
+    namespace component {
+        namespace type_ {
+            namespace external {
+                namespace import_ {
+                    type l_entry = Imports_.D;
+                    type l_id = string;
+                }
+                type import_ = {
+                    readonly 'l entry': import_.l_entry;
+                    readonly 'l id': import_.l_id;
+                };
+                namespace module_ {
+                    type l_entry = Modules_.D;
+                    type l_id = string;
+                }
+                type module_ = {
+                    readonly 'l entry': module_.l_entry;
+                    readonly 'l id': module_.l_id;
+                };
+            }
+            type external = {
+                readonly 'import': external.import_;
+                readonly 'module': external.module_;
+            };
+            namespace internal {
+                type l_entry = _pi.Circular_Dependency<Modules_.D>;
+                type l_id = string;
+            }
+            type internal = {
+                readonly 'l entry': internal.l_entry;
+                readonly 'l id': internal.l_id;
+            };
+            namespace internal_acyclic {
+                type l_entry = Modules_.D;
+                type l_id = string;
+            }
+            type internal_acyclic = {
+                readonly 'l entry': internal_acyclic.l_entry;
+                readonly 'l id': internal_acyclic.l_id;
+            };
+        }
+        type type_ = readonly ['external', type_.external] | readonly ['internal', type_.internal] | readonly ['internal acyclic', type_.internal_acyclic];
+        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_ {
+        namespace global {
+            type l_entry = Globals_.number_types.D;
+            type l_id = string;
+        }
+        type global = {
+            readonly 'l entry': global.l_entry;
+            readonly 'l id': global.l_id;
+        };
+        type local = Number_Type_;
+    }
+    type number_ = readonly ['global', number_.global] | readonly ['local', number_.local];
+    type optional = Value_;
+    namespace reference {
+        type referent = Value_Reference_;
+        namespace type_ {
+            type derived = null;
+            namespace selected {
+                type dictionary = Dictionary_;
+                namespace dependency {
+                    type acyclic = null;
+                    type cyclic = null;
+                    type stack = null;
+                }
+                type dependency = readonly ['acyclic', dependency.acyclic] | readonly ['cyclic', dependency.cyclic] | readonly ['stack', dependency.stack];
+            }
+            type selected = {
+                readonly 'dictionary': selected.dictionary;
+                readonly 'dependency': selected.dependency;
+            };
+        }
+        type type_ = readonly ['derived', type_.derived] | readonly ['selected', type_.selected];
+    }
+    type reference = {
+        readonly 'referent': reference.referent;
+        readonly 'type': reference.type_;
+    };
+    namespace state {
+        namespace options {
+            namespace D {
+                type constraints = Option_Constraints_;
+                namespace description {
+                    type O = string;
+                }
+                type description = _pi.Optional_Value<description.O>;
+                type value = Value_;
+            }
+            type D = {
+                readonly 'constraints': D.constraints;
+                readonly 'description': D.description;
+                readonly 'value': D.value;
+            };
+        }
+        type options = _pi.Dictionary<options.D>;
+        type results = Value_Results_;
+    }
+    type state = {
+        readonly 'options': state.options;
+        readonly 'results': state.results;
+    };
+    namespace text {
+        namespace global {
+            type l_entry = Globals_.text_types.D;
+            type l_id = string;
+        }
+        type global = {
+            readonly 'l entry': global.l_entry;
+            readonly 'l id': global.l_id;
+        };
+        type local = Text_Type_;
+    }
+    type text = readonly ['global', text.global] | readonly ['local', text.local];
+}
+export type Value_ = readonly ['boolean', Value_.boolean_] | readonly ['component', Value_.component] | readonly ['dictionary', Value_.dictionary] | readonly ['group', Value_.group] | readonly ['list', Value_.list] | readonly ['nothing', Value_.nothing] | readonly ['number', Value_.number_] | readonly ['optional', Value_.optional] | readonly ['reference', Value_.reference] | readonly ['state', Value_.state] | readonly ['text', Value_.text];
+export declare namespace Signatures_ {
+    type D = Signature_;
+}
+export type Signatures_ = _pi.Dictionary<Signatures_.D>;
+export declare namespace Signature_Parameters_ {
+    namespace modules {
+        namespace D {
+            type module_ = Module_Reference_;
+            type presence = Presence_;
+        }
+        type D = {
+            readonly 'module': D.module_;
+            readonly 'presence': D.presence;
+        };
+    }
+    type modules = _pi.Dictionary<modules.D>;
+    namespace lookups {
+        namespace D {
+            type referent = Module_Reference_;
+            type dictionary = Dictionary_;
+            namespace type_ {
+                type cyclic = null;
+                type acyclic = null;
+                type stack = null;
+            }
+            type type_ = readonly ['cyclic', type_.cyclic] | readonly ['acyclic', type_.acyclic] | readonly ['stack', type_.stack];
+            type presence = Presence_;
+        }
+        type D = {
+            readonly 'referent': D.referent;
+            readonly 'dictionary': D.dictionary;
+            readonly 'type': D.type_;
+            readonly 'presence': D.presence;
+        };
+    }
+    type lookups = _pi.Dictionary<lookups.D>;
+}
+export type Signature_Parameters_ = {
+    readonly 'modules': Signature_Parameters_.modules;
+    readonly 'lookups': Signature_Parameters_.lookups;
+};
+export declare namespace Value_Resolver_ {
+    type boolean_ = null;
+    namespace component {
+        type definition = Value_.component;
+        namespace location {
+            namespace external {
+                namespace import_ {
+                    type l_entry = Imports_.D;
+                    type l_id = string;
+                }
+                type import_ = {
+                    readonly 'l entry': import_.l_entry;
+                    readonly 'l id': import_.l_id;
+                };
+                namespace signature {
+                    type l_entry = Signatures_.D;
+                    type l_id = string;
+                }
+                type signature = {
+                    readonly 'l entry': signature.l_entry;
+                    readonly 'l id': signature.l_id;
+                };
+            }
+            type external = {
+                readonly 'import': external.import_;
+                readonly 'signature': external.signature;
+            };
+            namespace internal {
+                type l_entry = Signatures_.D;
+                type l_id = string;
+            }
+            type internal = {
+                readonly 'l entry': internal.l_entry;
+                readonly 'l id': internal.l_id;
+            };
+        }
+        type location = readonly ['external', location.external] | readonly ['internal', location.internal];
+        type signature = Signatures_.D;
+        namespace arguments_ {
+            namespace O {
+                namespace modules {
+                    namespace O {
+                        namespace D {
+                            type optional = Optional_Value_Initialization_;
+                            type required = Guaranteed_Value_Selection_;
+                            namespace parameter {
+                                type l_entry = Signature_Parameters_.modules.D;
+                                type l_id = string;
+                            }
+                            type parameter = {
+                                readonly 'l entry': parameter.l_entry;
+                                readonly 'l id': parameter.l_id;
+                            };
+                        }
+                        type D = readonly ['optional', D.optional] | readonly ['required', D.required] | readonly ['parameter', D.parameter];
+                    }
+                    type O = _pi.Dictionary<O.D>;
+                }
+                type modules = _pi.Optional_Value<modules.O>;
+                namespace lookups {
+                    namespace O {
+                        namespace D {
+                            namespace stack {
+                                type empty = null;
+                                namespace push {
+                                    type stack = Lookup_Selection_;
+                                    type item = Lookup_Selection_;
+                                }
+                                type push = {
+                                    readonly 'stack': push.stack;
+                                    readonly 'item': push.item;
+                                };
+                            }
+                            type stack = readonly ['empty', stack.empty] | readonly ['push', stack.push];
+                            namespace acyclic {
+                                type not_set = null;
+                            }
+                            type acyclic = readonly ['not set', acyclic.not_set];
+                            namespace cyclic {
+                                type not_set = null;
+                            }
+                            type cyclic = readonly ['not set', cyclic.not_set];
+                            type selection = Lookup_Selection_;
+                        }
+                        type D = readonly ['stack', D.stack] | readonly ['acyclic', D.acyclic] | readonly ['cyclic', D.cyclic] | readonly ['selection', D.selection];
+                    }
+                    type O = _pi.Dictionary<O.D>;
+                }
+                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 = Dictionary_;
+        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 = Value_.list;
+        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 = Value_.reference;
+        namespace type_ {
+            namespace derived {
+                type value = Guaranteed_Value_Selection_;
+            }
+            type derived = {
+                readonly 'value': derived.value;
+            };
+            namespace selected {
+                type definition = Value_.reference.type_.selected;
+                type lookup = Lookup_Selection_;
+                type constraints = Value_Constraint_Resolvers_;
+            }
+            type selected = {
+                readonly 'definition': selected.definition;
+                readonly 'lookup': selected.lookup;
+                readonly 'constraints': selected.constraints;
+            };
+        }
+        type type_ = readonly ['derived', type_.derived] | readonly ['selected', type_.selected];
+    }
+    type reference = {
+        readonly 'definition': reference.definition;
+        readonly 'type': reference.type_;
+    };
+    namespace state {
+        type definition = Value_.state;
+        namespace states {
+            namespace D {
+                type constraints = Option_Constraint_Resolvers_;
+                type resolver = Value_Resolver_;
+            }
+            type D = {
+                readonly 'constraints': D.constraints;
+                readonly 'resolver': D.resolver;
+            };
+        }
+        type states = _pi.Dictionary<states.D>;
+    }
+    type state = {
+        readonly 'definition': state.definition;
+        readonly 'states': state.states;
+    };
+    type text = null;
+}
+export type Value_Resolver_ = readonly ['boolean', Value_Resolver_.boolean_] | readonly ['component', Value_Resolver_.component] | readonly ['dictionary', Value_Resolver_.dictionary] | readonly ['group', Value_Resolver_.group] | readonly ['list', Value_Resolver_.list] | readonly ['nothing', Value_Resolver_.nothing] | readonly ['number', Value_Resolver_.number_] | readonly ['optional', Value_Resolver_.optional] | readonly ['reference', Value_Resolver_.reference] | readonly ['state', Value_Resolver_.state] | readonly ['text', Value_Resolver_.text];
+export declare namespace Module_Specification_ {
+    type schema = Schema_Tree_;
+    namespace schema_path {
+        type L = string;
+    }
+    type schema_path = _pi.List<schema_path.L>;
+    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 schema = Schema_;
+    type set_ = Schemas_;
+}
+export type Schema_Tree_ = readonly ['schema', Schema_Tree_.schema] | readonly ['set', Schema_Tree_.set_];
+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 multi_line = null;
+        type single_line = null;
+    }
+    type type_ = readonly ['multi line', type_.multi_line] | readonly ['single line', type_.single_line];
+}
+export type Text_Type_ = {
+    readonly 'type': Text_Type_.type_;
+};
+export declare namespace Number_Type_ {
+    namespace precision {
+        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 integer = null;
+                type natural = null;
+                type positive_natural = null;
+            }
+            type type_ = readonly ['integer', type_.integer] | readonly ['natural', type_.natural] | readonly ['positive natural', type_.positive_natural];
+        }
+        type exact = {
+            readonly 'decimal separator offset': exact.decimal_separator_offset;
+            readonly 'type': exact.type_;
+        };
+    }
+    type precision = readonly ['approximation', precision.approximation] | readonly ['exact', precision.exact];
+}
+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 optional = null;
+    type required = null;
+}
+export type Presence_ = readonly ['optional', Presence_.optional] | readonly ['required', Presence_.required];
+export declare namespace Module_Resolvers_ {
+    namespace D {
+        type signature = Signatures_.D;
+        type root_value_resolver = Value_Resolver_;
+    }
+    type D = {
+        readonly 'signature': D.signature;
+        readonly 'root value resolver': D.root_value_resolver;
+    };
+}
+export type Module_Resolvers_ = _pi.Dictionary<Module_Resolvers_.D>;
+export declare namespace Benchmark_ {
+    namespace selection {
+        namespace l_results {
+            type dictionary = Value_.dictionary;
+        }
+        type l_results = {
+            readonly 'dictionary': l_results.dictionary;
+        };
+        type l_value = Guaranteed_Value_Selection_;
+    }
+    type selection = {
+        readonly 'l results': selection.l_results;
+        readonly 'l value': selection.l_value;
+    };
+    type resulting_dictionary = Dictionary_;
+    type dense = boolean;
+}
+export type Benchmark_ = {
+    readonly 'selection': Benchmark_.selection;
+    readonly 'resulting dictionary': Benchmark_.resulting_dictionary;
+    readonly 'dense': Benchmark_.dense;
+};
+export declare namespace Group_ {
+    namespace D {
+        namespace description {
+            type O = string;
+        }
+        type description = _pi.Optional_Value<description.O>;
+        type value = Value_;
+    }
+    type D = {
+        readonly 'description': D.description;
+        readonly 'value': D.value;
+    };
+}
+export type Group_ = _pi.Dictionary<Group_.D>;
+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 {
+        namespace l_results {
+            type result = Value_;
+        }
+        type l_results = {
+            readonly 'result': l_results.result;
+        };
+        namespace l_value {
+            namespace L {
+                namespace l_results {
+                    type result = Value_;
+                }
+                type l_results = {
+                    readonly 'result': l_results.result;
+                };
+                namespace l_item {
+                    namespace l_results {
+                        type value = Value_;
+                    }
+                    type l_results = {
+                        readonly 'value': l_results.value;
+                    };
+                    namespace l_value {
+                        type dictionary = null;
+                        namespace group {
+                            type l_entry = Group_.D;
+                            type l_id = string;
+                        }
+                        type group = {
+                            readonly 'l entry': group.l_entry;
+                            readonly 'l id': group.l_id;
+                        };
+                        type list = null;
+                        type optional = null;
+                        namespace state {
+                            type l_entry = Value_.state.options.D;
+                            type l_id = string;
+                        }
+                        type state = {
+                            readonly 'l entry': state.l_entry;
+                            readonly 'l id': state.l_id;
+                        };
+                    }
+                    type l_value = readonly ['dictionary', l_value.dictionary] | readonly ['group', l_value.group] | readonly ['list', l_value.list] | readonly ['optional', l_value.optional] | readonly ['state', l_value.state];
+                }
+                type l_item = {
+                    readonly 'l results': l_item.l_results;
+                    readonly 'l value': l_item.l_value;
+                };
+            }
+            type L = {
+                readonly 'l results': L.l_results;
+                readonly 'l item': L.l_item;
+            };
+        }
+        type l_value = _pi.List<l_value.L>;
+    }
+    type tail = {
+        readonly 'l results': tail.l_results;
+        readonly 'l value': tail.l_value;
+    };
+    type resulting_node = Value_;
+}
+export type Value_Path_ = {
+    readonly 'tail': Value_Path_.tail;
+    readonly 'resulting node': Value_Path_.resulting_node;
+};
+export declare namespace Module_Reference_ {
+    namespace location {
+        namespace internal {
+            type l_entry = Modules_.D;
+            type l_id = string;
+        }
+        type internal = {
+            readonly 'l entry': internal.l_entry;
+            readonly 'l id': internal.l_id;
+        };
+        namespace external {
+            namespace import_ {
+                type l_entry = Imports_.D;
+                type l_id = string;
+            }
+            type import_ = {
+                readonly 'l entry': import_.l_entry;
+                readonly 'l id': import_.l_id;
+            };
+            namespace module_ {
+                type l_entry = Modules_.D;
+                type l_id = string;
+            }
+            type module_ = {
+                readonly 'l entry': module_.l_entry;
+                readonly 'l id': module_.l_id;
+            };
+        }
+        type external = {
+            readonly 'import': external.import_;
+            readonly 'module': external.module_;
+        };
+    }
+    type location = readonly ['internal', location.internal] | readonly ['external', location.external];
+    type resulting_module = Module_;
+}
+export type Module_Reference_ = {
+    readonly 'location': Module_Reference_.location;
+    readonly 'resulting module': Module_Reference_.resulting_module;
+};
+export declare namespace Signature_ {
+    type module_ = Module_;
+    namespace parameters {
+        type local = Signature_Parameters_;
+        namespace same_as {
+            type l_entry = Signatures_.D;
+            type l_id = string;
+        }
+        type same_as = {
+            readonly 'l entry': same_as.l_entry;
+            readonly 'l id': same_as.l_id;
+        };
+    }
+    type parameters = readonly ['local', parameters.local] | readonly ['same as', parameters.same_as];
+    type resolved_parameters = Signature_Parameters_;
+}
+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 {
+        namespace l_results {
+            type result = Value_;
+        }
+        type l_results = {
+            readonly 'result': l_results.result;
+        };
+        namespace l_value {
+            namespace L {
+                namespace l_results {
+                    type result = Value_;
+                }
+                type l_results = {
+                    readonly 'result': l_results.result;
+                };
+                namespace l_item {
+                    type component = null;
+                    namespace group {
+                        type l_entry = Group_.D;
+                        type l_id = string;
+                    }
+                    type group = {
+                        readonly 'l entry': group.l_entry;
+                        readonly 'l id': group.l_id;
+                    };
+                    namespace reference {
+                        type definition = Value_.reference;
+                    }
+                    type reference = {
+                        readonly 'definition': reference.definition;
+                    };
+                }
+                type l_item = readonly ['component', l_item.component] | readonly ['group', l_item.group] | readonly ['reference', l_item.reference];
+            }
+            type L = {
+                readonly 'l results': L.l_results;
+                readonly 'l item': L.l_item;
+            };
+        }
+        type l_value = _pi.List<l_value.L>;
+    }
+    type path = {
+        readonly 'l results': path.l_results;
+        readonly 'l value': path.l_value;
+    };
+    type resulting_node = Value_;
+}
+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_ {
+        namespace acyclic {
+            type siblings = Dictionary_;
+            namespace resolved_dictionary {
+                type selection = Guaranteed_Value_Selection_;
+                type selected_dictionary = Dictionary_;
+            }
+            type resolved_dictionary = {
+                readonly 'selection': resolved_dictionary.selection;
+                readonly 'selected dictionary': resolved_dictionary.selected_dictionary;
+            };
+        }
+        type acyclic = readonly ['siblings', acyclic.siblings] | readonly ['resolved dictionary', acyclic.resolved_dictionary];
+        namespace cyclic {
+            type siblings = Dictionary_;
+        }
+        type cyclic = readonly ['siblings', cyclic.siblings];
+        namespace parameter {
+            type l_entry = Signature_Parameters_.lookups.D;
+            type l_id = string;
+        }
+        type parameter = {
+            readonly 'l entry': parameter.l_entry;
+            readonly 'l id': parameter.l_id;
+        };
+    }
+    type type_ = readonly ['acyclic', type_.acyclic] | readonly ['cyclic', type_.cyclic] | readonly ['parameter', type_.parameter];
+    type resulting_dictionary = Dictionary_;
+}
+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_ {
+        namespace state {
+            type selected_state = Value_.state;
+            namespace option {
+                type l_entry = Value_.state.options.D;
+                type l_id = string;
+            }
+            type option = {
+                readonly 'l entry': option.l_entry;
+                readonly 'l id': option.l_id;
+            };
+        }
+        type state = {
+            readonly 'selected state': state.selected_state;
+            readonly 'option': state.option;
+        };
+        namespace optional_value {
+            type selected_optional_value = Value_.optional;
+        }
+        type optional_value = {
+            readonly 'selected optional value': optional_value.selected_optional_value;
+        };
+    }
+    type type_ = readonly ['state', type_.state] | readonly ['optional value', type_.optional_value];
+}
+export type Constraint_ = {
+    readonly 'selection': Constraint_.selection;
+    readonly 'type': Constraint_.type_;
+};
+export declare namespace Option_Constraint_Resolvers_ {
+    namespace D {
+        namespace state {
+            type selection = Guaranteed_Value_Selection_;
+            type selected_state = Value_.state;
+            namespace option {
+                type l_entry = Value_.state.options.D;
+                type l_id = string;
+            }
+            type option = {
+                readonly 'l entry': option.l_entry;
+                readonly 'l id': option.l_id;
+            };
+        }
+        type state = {
+            readonly 'selection': state.selection;
+            readonly 'selected state': state.selected_state;
+            readonly 'option': state.option;
+        };
+        type assert_is_set = Possible_Value_Selection_;
+    }
+    type D = readonly ['state', D.state] | readonly ['assert is set', D.assert_is_set];
+}
+export type Option_Constraint_Resolvers_ = _pi.Dictionary<Option_Constraint_Resolvers_.D>;
+export declare namespace Value_Constraint_Resolvers_ {
+    type D = Value_Constraint_Resolver_;
+}
+export type Value_Constraint_Resolvers_ = _pi.Dictionary<Value_Constraint_Resolvers_.D>;
+export declare namespace Reference_To_Value_Constraint_Resolver_ {
+    type l_entry = Value_Constraint_Resolvers_.D;
+    type l_id = string;
+}
+export type Reference_To_Value_Constraint_Resolver_ = {
+    readonly 'l entry': Reference_To_Value_Constraint_Resolver_.l_entry;
+    readonly 'l id': Reference_To_Value_Constraint_Resolver_.l_id;
+};
+export declare namespace Value_Constraint_Resolver_ {
+    namespace start {
+        type property = null;
+        type sibling = Reference_To_Value_Constraint_Resolver_;
+    }
+    type start = readonly ['property', start.property] | readonly ['sibling', start.sibling];
+    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 not_set = null;
+    type set_ = Guaranteed_Value_Selection_;
+    type selection = Possible_Value_Selection_;
+}
+export type Optional_Value_Initialization_ = readonly ['not set', Optional_Value_Initialization_.not_set] | readonly ['set', Optional_Value_Initialization_.set_] | readonly ['selection', Optional_Value_Initialization_.selection];
+export declare namespace Value_Resolver_Group_ {
+    namespace D {
+        type definition = Group_.D;
+        type resolver = Value_Resolver_;
+    }
+    type D = {
+        readonly 'definition': D.definition;
+        readonly 'resolver': D.resolver;
+    };
+}
+export type Value_Resolver_Group_ = _pi.Dictionary<Value_Resolver_Group_.D>;
+export type Value_Resolver_List_Result_ = Module_Reference_;
+export declare namespace Value_Results_ {
+    namespace O {
+        type D = Value_Reference_;
+    }
+    type O = _pi.Dictionary<O.D>;
+}
+export type Value_Results_ = _pi.Optional_Value<Value_Results_.O>;
+export declare namespace Option_Constraints_ {
+    namespace O {
+        type D = Value_Reference_;
+    }
+    type O = _pi.Dictionary<O.D>;
+}
+export type Option_Constraints_ = _pi.Optional_Value<Option_Constraints_.O>;
+export declare namespace Guaranteed_Value_Selection_ {
+    namespace start {
+        namespace sibling {
+            type l_entry = Value_Resolver_Group_.D;
+            type l_id = string;
+        }
+        type sibling = {
+            readonly 'l entry': sibling.l_entry;
+            readonly 'l id': sibling.l_id;
+        };
+        namespace parent_sibling {
+            type l_entry = Value_Resolver_Group_.D;
+            type l_id = string;
+        }
+        type parent_sibling = {
+            readonly 'l entry': parent_sibling.l_entry;
+            readonly 'l id': parent_sibling.l_id;
+        };
+        namespace option_constraint {
+            type l_entry = Option_Constraint_Resolvers_.D;
+            type l_id = string;
+        }
+        type option_constraint = {
+            readonly 'l entry': option_constraint.l_entry;
+            readonly 'l id': option_constraint.l_id;
+        };
+        type list_cursor = null;
+        type linked_entry = null;
+        namespace constraint {
+            namespace component {
+                namespace property {
+                    type l_entry = Value_Resolver_Group_.D;
+                    type l_id = string;
+                }
+                type property = {
+                    readonly 'l entry': property.l_entry;
+                    readonly 'l id': property.l_id;
+                };
+                namespace constraint {
+                    type l_entry = Value_Constraint_Resolvers_.D;
+                    type l_id = string;
+                }
+                type constraint = {
+                    readonly 'l entry': constraint.l_entry;
+                    readonly 'l id': constraint.l_id;
+                };
+            }
+            type component = {
+                readonly 'property': component.property;
+                readonly 'constraint': component.constraint;
+            };
+            namespace reference {
+                namespace property {
+                    type l_entry = Value_Resolver_Group_.D;
+                    type l_id = string;
+                }
+                type property = {
+                    readonly 'l entry': property.l_entry;
+                    readonly 'l id': property.l_id;
+                };
+                namespace constraint {
+                    type l_entry = Value_Constraint_Resolvers_.D;
+                    type l_id = string;
+                }
+                type constraint = {
+                    readonly 'l entry': constraint.l_entry;
+                    readonly 'l id': constraint.l_id;
+                };
+            }
+            type reference = {
+                readonly 'property': reference.property;
+                readonly 'constraint': reference.constraint;
+            };
+        }
+        type constraint = readonly ['component', constraint.component] | readonly ['reference', constraint.reference];
+        namespace parameter {
+            type l_entry = Signature_Parameters_.modules.D;
+            type l_id = string;
+        }
+        type parameter = {
+            readonly 'l entry': parameter.l_entry;
+            readonly 'l id': parameter.l_id;
+        };
+        namespace result {
+            namespace list {
+                namespace property {
+                    type l_entry = Value_Resolver_Group_.D;
+                    type l_id = string;
+                }
+                type property = {
+                    readonly 'l entry': property.l_entry;
+                    readonly 'l id': property.l_id;
+                };
+                type list_result = Value_Resolver_.list.result.O;
+            }
+            type list = {
+                readonly 'property': list.property;
+                readonly 'list result': list.list_result;
+            };
+            namespace state {
+                namespace property {
+                    type l_entry = Value_Resolver_Group_.D;
+                    type l_id = string;
+                }
+                type property = {
+                    readonly 'l entry': property.l_entry;
+                    readonly 'l id': property.l_id;
+                };
+                type state = Value_Resolver_.state;
+                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_entry = Value_Resolver_Group_.D;
+                    type l_id = string;
+                }
+                type property = {
+                    readonly 'l entry': property.l_entry;
+                    readonly 'l id': property.l_id;
+                };
+                type optional_value = Value_Resolver_.optional;
+                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 result = readonly ['list', result.list] | readonly ['state', result.state] | readonly ['optional value', result.optional_value];
+    }
+    type start = readonly ['sibling', start.sibling] | readonly ['parent sibling', start.parent_sibling] | readonly ['option constraint', start.option_constraint] | readonly ['list cursor', start.list_cursor] | readonly ['linked entry', start.linked_entry] | readonly ['constraint', start.constraint] | readonly ['parameter', start.parameter] | readonly ['result', start.result];
+    type tail = Relative_Value_Selection_;
+    type resulting_node = Value_;
+}
+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_ {
+    namespace parameter {
+        type l_entry = Signature_Parameters_.modules.D;
+        type l_id = string;
+    }
+    type parameter = {
+        readonly 'l entry': parameter.l_entry;
+        readonly 'l id': parameter.l_id;
+    };
+    namespace result {
+        namespace state {
+            namespace property {
+                type l_entry = Value_Resolver_Group_.D;
+                type l_id = string;
+            }
+            type property = {
+                readonly 'l entry': property.l_entry;
+                readonly 'l id': property.l_id;
+            };
+            type state = Value_Resolver_.state;
+            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_entry = Value_Resolver_Group_.D;
+                type l_id = string;
+            }
+            type property = {
+                readonly 'l entry': property.l_entry;
+                readonly 'l id': property.l_id;
+            };
+            type optional_value = Value_Resolver_.optional;
+            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 result = readonly ['state', result.state] | readonly ['optional value', result.optional_value];
+}
+export type Possible_Value_Selection_ = readonly ['parameter', Possible_Value_Selection_.parameter] | readonly ['result', Possible_Value_Selection_.result];
+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, };