pareto-liana 0.0.0

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

@@ -0,0 +1,971 @@
+import * as _pi from "pareto-core-interface";
+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 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 Type_Parameters_ {
+    type D = null;
+}
+export type Type_Parameters_ = _pi.Dictionary<Type_Parameters_.D>;
+export declare namespace Type_ {
+    type type_parameters = Type_Parameters_;
+    type node = Type_Node_;
+}
+export type Type_ = {
+    readonly 'type parameters': Type_.type_parameters;
+    readonly 'node': Type_.node;
+};
+export declare namespace Types_ {
+    type D = Type_;
+}
+export type Types_ = _pi.Dictionary<Types_.D>;
+export declare namespace Resolve_Logic_ {
+    namespace signatures {
+        type types = Signatures_;
+    }
+    type signatures = {
+        readonly 'types': signatures.types;
+    };
+    type resolvers = Resolvers_;
+}
+export type Resolve_Logic_ = {
+    readonly 'signatures': Resolve_Logic_.signatures;
+    readonly 'resolvers': Resolve_Logic_.resolvers;
+};
+export declare namespace Schema_ {
+    type imports = Imports_;
+    type globals = Globals_;
+    type types = Types_;
+    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 'types': Schema_.types;
+    readonly 'complexity': Schema_.complexity;
+};
+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 Type_Specification_ {
+    type schema = Schema_Tree_;
+    namespace schema_path {
+        type L = string;
+    }
+    type schema_path = _pi.List<schema_path.L>;
+    type _type = string;
+}
+export type Type_Specification_ = {
+    readonly 'schema': Type_Specification_.schema;
+    readonly 'schema path': Type_Specification_.schema_path;
+    readonly 'type': Type_Specification_._type;
+};
+export declare namespace Schemas_ {
+    type D = Schema_Tree_;
+}
+export type Schemas_ = _pi.Dictionary<Schemas_.D>;
+export declare namespace Imports_ {
+    namespace D {
+        namespace schema_set_child {
+            type entry = Schemas_.D;
+            type key = string;
+        }
+        type schema_set_child = {
+            readonly 'entry': schema_set_child.entry;
+            readonly 'key': schema_set_child.key;
+        };
+        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 Presence_ {
+    type optional = null;
+    type required = null;
+}
+export type Presence_ = readonly ['optional', Presence_.optional] | readonly ['required', Presence_.required];
+export declare namespace Dictionary_ {
+    type node = Type_Node_;
+    type ordered = boolean;
+}
+export type Dictionary_ = {
+    readonly 'node': Dictionary_.node;
+    readonly 'ordered': Dictionary_.ordered;
+};
+export declare namespace Signatures_ {
+    type D = Signature_;
+}
+export type Signatures_ = _pi.Dictionary<Signatures_.D>;
+export declare namespace Resolvers_ {
+    namespace D {
+        type signature = Signatures_.D;
+        type type_resolver = Node_Resolver_;
+    }
+    type D = {
+        readonly 'signature': D.signature;
+        readonly 'type resolver': D.type_resolver;
+    };
+}
+export type Resolvers_ = _pi.Dictionary<Resolvers_.D>;
+export declare namespace Group_ {
+    namespace D {
+        namespace description {
+            type O = string;
+        }
+        type description = _pi.Optional_Value<description.O>;
+        type node = Type_Node_;
+    }
+    type D = {
+        readonly 'description': D.description;
+        readonly 'node': D.node;
+    };
+}
+export type Group_ = _pi.Dictionary<Group_.D>;
+export declare namespace Type_Node_ {
+    type _boolean = null;
+    namespace component {
+        namespace external {
+            namespace _import {
+                type entry = Imports_.D;
+                type key = string;
+            }
+            type _import = {
+                readonly 'entry': _import.entry;
+                readonly 'key': _import.key;
+            };
+            namespace _type {
+                type entry = Types_.D;
+                type key = string;
+            }
+            type _type = {
+                readonly 'entry': _type.entry;
+                readonly 'key': _type.key;
+            };
+        }
+        type external = {
+            readonly 'import': external._import;
+            readonly 'type': external._type;
+        };
+        namespace internal {
+            type entry = Types_.D;
+            type key = string;
+        }
+        type internal = {
+            readonly 'entry': internal.entry;
+            readonly 'key': internal.key;
+        };
+        namespace internal_cyclic {
+            type entry = Types_.D;
+            type key = string;
+        }
+        type internal_cyclic = {
+            readonly 'entry': _pi.Circular_Dependency<internal_cyclic.entry>;
+            readonly 'key': internal_cyclic.key;
+        };
+    }
+    type component = readonly ['external', component.external] | readonly ['internal', component.internal] | readonly ['internal cyclic', component.internal_cyclic];
+    type dictionary = Dictionary_;
+    type group = Group_;
+    namespace list {
+        type node = Type_Node_;
+    }
+    type list = {
+        readonly 'node': list.node;
+    };
+    type nothing = null;
+    namespace _number {
+        namespace global {
+            type entry = Globals_.number_types.D;
+            type key = string;
+        }
+        type global = {
+            readonly 'entry': global.entry;
+            readonly 'key': global.key;
+        };
+        type local = Number_Type_;
+    }
+    type _number = readonly ['global', _number.global] | readonly ['local', _number.local];
+    type optional = Type_Node_;
+    namespace reference {
+        type referent = Type_Node_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_group {
+        namespace D {
+            namespace description {
+                type O = string;
+            }
+            type description = _pi.Optional_Value<description.O>;
+            type node = Type_Node_;
+        }
+        type D = {
+            readonly 'description': D.description;
+            readonly 'node': D.node;
+        };
+    }
+    type state_group = _pi.Dictionary<state_group.D>;
+    namespace text {
+        namespace global {
+            type entry = Globals_.text_types.D;
+            type key = string;
+        }
+        type global = {
+            readonly 'entry': global.entry;
+            readonly 'key': global.key;
+        };
+        type local = Text_Type_;
+    }
+    type text = readonly ['global', text.global] | readonly ['local', text.local];
+}
+export type Type_Node_ = readonly ['boolean', Type_Node_._boolean] | readonly ['component', Type_Node_.component] | readonly ['dictionary', Type_Node_.dictionary] | readonly ['group', Type_Node_.group] | readonly ['list', Type_Node_.list] | readonly ['nothing', Type_Node_.nothing] | readonly ['number', Type_Node_._number] | readonly ['optional', Type_Node_.optional] | readonly ['reference', Type_Node_.reference] | readonly ['state group', Type_Node_.state_group] | readonly ['text', Type_Node_.text];
+export declare namespace Type_Reference_ {
+    namespace location {
+        namespace internal {
+            type entry = Types_.D;
+            type key = string;
+        }
+        type internal = {
+            readonly 'entry': internal.entry;
+            readonly 'key': internal.key;
+        };
+        namespace external {
+            namespace _import {
+                type entry = Imports_.D;
+                type key = string;
+            }
+            type _import = {
+                readonly 'entry': _import.entry;
+                readonly 'key': _import.key;
+            };
+            namespace _type {
+                type entry = Types_.D;
+                type key = string;
+            }
+            type _type = {
+                readonly 'entry': _type.entry;
+                readonly 'key': _type.key;
+            };
+        }
+        type external = {
+            readonly 'import': external._import;
+            readonly 'type': external._type;
+        };
+    }
+    type location = readonly ['internal', location.internal] | readonly ['external', location.external];
+    type resulting_node = Type_Node_;
+}
+export type Type_Reference_ = {
+    readonly 'location': Type_Reference_.location;
+    readonly 'resulting node': Type_Reference_.resulting_node;
+};
+export declare namespace Type_Node_Reference_ {
+    type type_location = Type_Reference_;
+    namespace tail {
+        namespace L {
+            type dictionary = null;
+            namespace group {
+                type entry = Group_.D;
+                type key = string;
+            }
+            type group = {
+                readonly 'entry': group.entry;
+                readonly 'key': group.key;
+            };
+            type list = null;
+            type optional = null;
+            namespace state_group {
+                type entry = Type_Node_.state_group.D;
+                type key = string;
+            }
+            type state_group = {
+                readonly 'entry': state_group.entry;
+                readonly 'key': state_group.key;
+            };
+        }
+        type L = readonly ['dictionary', L.dictionary] | readonly ['group', L.group] | readonly ['list', L.list] | readonly ['optional', L.optional] | readonly ['state group', L.state_group];
+    }
+    type tail = _pi.List<tail.L>;
+    type resulting_node = Type_Node_;
+}
+export type Type_Node_Reference_ = {
+    readonly 'type location': Type_Node_Reference_.type_location;
+    readonly 'tail': Type_Node_Reference_.tail;
+    readonly 'resulting node': Type_Node_Reference_.resulting_node;
+};
+export declare namespace Signature_Parameters_ {
+    namespace values {
+        namespace D {
+            type data_type = Type_Reference_;
+            type presence = Presence_;
+        }
+        type D = {
+            readonly 'data type': D.data_type;
+            readonly 'presence': D.presence;
+        };
+    }
+    type values = _pi.Dictionary<values.D>;
+    namespace lookups {
+        namespace D {
+            type referent = Type_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 'values': Signature_Parameters_.values;
+    readonly 'lookups': Signature_Parameters_.lookups;
+};
+export declare namespace Signature_ {
+    type _type = Type_;
+    namespace parameters {
+        type local = Signature_Parameters_;
+        namespace same_as {
+            type entry = Signatures_.D;
+            type key = string;
+        }
+        type same_as = {
+            readonly 'entry': same_as.entry;
+            readonly 'key': same_as.key;
+        };
+    }
+    type parameters = readonly ['local', parameters.local] | readonly ['same as', parameters.same_as];
+    type resolved_parameters = Signature_Parameters_;
+}
+export type Signature_ = {
+    readonly 'type': Signature_._type;
+    readonly 'parameters': Signature_.parameters;
+    readonly 'resolved parameters': Signature_.resolved_parameters;
+};
+export declare namespace Relative_Value_Selection_ {
+    namespace path {
+        namespace L {
+            type component = null;
+            namespace group {
+                type entry = Group_.D;
+                type key = string;
+            }
+            type group = {
+                readonly 'entry': group.entry;
+                readonly 'key': group.key;
+            };
+            namespace reference {
+                type definition = Type_Node_.reference;
+            }
+            type reference = {
+                readonly 'definition': reference.definition;
+            };
+        }
+        type L = readonly ['component', L.component] | readonly ['group', L.group] | readonly ['reference', L.reference];
+    }
+    type path = _pi.List<path.L>;
+    type resulting_node = Type_Node_;
+}
+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 dictionary {
+            type selection = Guaranteed_Value_Selection_;
+            type selected_dictionary = Dictionary_;
+        }
+        type dictionary = {
+            readonly 'selection': dictionary.selection;
+            readonly 'selected dictionary': dictionary.selected_dictionary;
+        };
+        namespace parameter {
+            type entry = Signature_Parameters_.lookups.D;
+            type key = string;
+        }
+        type parameter = {
+            readonly 'entry': parameter.entry;
+            readonly 'key': parameter.key;
+        };
+        type not_circular_dependent_siblings = Dictionary_;
+        type possibly_circular_dependent_siblings = Dictionary_;
+    }
+    type _type = readonly ['dictionary', _type.dictionary] | readonly ['parameter', _type.parameter] | readonly ['not circular dependent siblings', _type.not_circular_dependent_siblings] | readonly ['possibly circular dependent siblings', _type.possibly_circular_dependent_siblings];
+    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_group = Type_Node_.state_group;
+            namespace state {
+                type entry = Type_Node_.state_group.D;
+                type key = string;
+            }
+            type state = {
+                readonly 'entry': state.entry;
+                readonly 'key': state.key;
+            };
+        }
+        type state = {
+            readonly 'selected state group': state.selected_state_group;
+            readonly 'state': state.state;
+        };
+        namespace optional_value {
+            type selected_optional_value = Type_Node_.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_Constraints_ {
+    namespace D {
+        namespace state {
+            type selection = Guaranteed_Value_Selection_;
+            type selected_state_group = Type_Node_.state_group;
+            namespace state {
+                type entry = Type_Node_.state_group.D;
+                type key = string;
+            }
+            type state = {
+                readonly 'entry': state.entry;
+                readonly 'key': state.key;
+            };
+        }
+        type state = {
+            readonly 'selection': state.selection;
+            readonly 'selected state group': state.selected_state_group;
+            readonly 'state': state.state;
+        };
+        type assert_is_set = Possible_Value_Selection_;
+    }
+    type D = readonly ['state', D.state] | readonly ['assert is set', D.assert_is_set];
+}
+export type Option_Constraints_ = _pi.Dictionary<Option_Constraints_.D>;
+export declare namespace Property_Constraints_ {
+    type D = Property_Constraint_;
+}
+export type Property_Constraints_ = _pi.Dictionary<Property_Constraints_.D>;
+export declare namespace Reference_To_Property_Constraint_ {
+    type entry = Property_Constraints_.D;
+    type key = string;
+}
+export type Reference_To_Property_Constraint_ = {
+    readonly 'entry': Reference_To_Property_Constraint_.entry;
+    readonly 'key': Reference_To_Property_Constraint_.key;
+};
+export declare namespace Property_Constraint_ {
+    namespace start {
+        type property = null;
+        type sibling = Reference_To_Property_Constraint_;
+    }
+    type start = readonly ['property', start.property] | readonly ['sibling', start.sibling];
+    type constraint = Constraint_;
+}
+export type Property_Constraint_ = {
+    readonly 'start': Property_Constraint_.start;
+    readonly 'constraint': Property_Constraint_.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 Node_Resolver_Group_ {
+    namespace D {
+        type definition = Group_.D;
+        type resolver = Node_Resolver_;
+    }
+    type D = {
+        readonly 'definition': D.definition;
+        readonly 'resolver': D.resolver;
+    };
+}
+export type Node_Resolver_Group_ = _pi.Dictionary<Node_Resolver_Group_.D>;
+export type Node_Resolver_List_Result_ = Type_Reference_;
+export declare namespace Benchmark_ {
+    type selection = Guaranteed_Value_Selection_;
+    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 Node_Resolver_ {
+    type _boolean = null;
+    namespace component {
+        namespace location {
+            namespace external {
+                namespace _import {
+                    type entry = Imports_.D;
+                    type key = string;
+                }
+                type _import = {
+                    readonly 'entry': _import.entry;
+                    readonly 'key': _import.key;
+                };
+                namespace _type {
+                    type entry = Signatures_.D;
+                    type key = string;
+                }
+                type _type = {
+                    readonly 'entry': _type.entry;
+                    readonly 'key': _type.key;
+                };
+            }
+            type external = {
+                readonly 'import': external._import;
+                readonly 'type': external._type;
+            };
+            namespace internal {
+                type entry = Signatures_.D;
+                type key = string;
+            }
+            type internal = {
+                readonly 'entry': internal.entry;
+                readonly 'key': internal.key;
+            };
+        }
+        type location = readonly ['external', location.external] | readonly ['internal', location.internal];
+        type signature = Signatures_.D;
+        namespace _arguments {
+            namespace O {
+                namespace values {
+                    namespace O {
+                        namespace D {
+                            type optional = Optional_Value_Initialization_;
+                            type required = Guaranteed_Value_Selection_;
+                            namespace parameter {
+                                type entry = Signature_Parameters_.values.D;
+                                type key = string;
+                            }
+                            type parameter = {
+                                readonly 'entry': parameter.entry;
+                                readonly 'key': parameter.key;
+                            };
+                        }
+                        type D = readonly ['optional', D.optional] | readonly ['required', D.required] | readonly ['parameter', D.parameter];
+                    }
+                    type O = _pi.Dictionary<O.D>;
+                }
+                type values = _pi.Optional_Value<values.O>;
+                namespace lookups {
+                    namespace O {
+                        namespace D {
+                            type empty_stack = null;
+                            type not_set = null;
+                            type selection = Lookup_Selection_;
+                            namespace stack {
+                                type stack = Lookup_Selection_;
+                                type element = Lookup_Selection_;
+                            }
+                            type stack = {
+                                readonly 'stack': stack.stack;
+                                readonly 'element': stack.element;
+                            };
+                        }
+                        type D = readonly ['empty stack', D.empty_stack] | readonly ['not set', D.not_set] | readonly ['selection', D.selection] | readonly ['stack', D.stack];
+                    }
+                    type O = _pi.Dictionary<O.D>;
+                }
+                type lookups = _pi.Optional_Value<lookups.O>;
+            }
+            type O = {
+                readonly 'values': O.values;
+                readonly 'lookups': O.lookups;
+            };
+        }
+        type _arguments = _pi.Optional_Value<_arguments.O>;
+        type constraints = Property_Constraints_;
+    }
+    type component = {
+        readonly 'location': component.location;
+        readonly 'signature': component.signature;
+        readonly 'arguments': component._arguments;
+        readonly 'constraints': component.constraints;
+    };
+    namespace dictionary {
+        type definition = Dictionary_;
+        type resolver = Node_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 = Node_Resolver_Group_;
+    namespace list {
+        type definition = Type_Node_.list;
+        type resolver = Node_Resolver_;
+        namespace result {
+            type O = Node_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_Constraints_;
+        type resolver = Node_Resolver_;
+    }
+    type optional = {
+        readonly 'constraints': optional.constraints;
+        readonly 'resolver': optional.resolver;
+    };
+    namespace reference {
+        type definition = Type_Node_.reference;
+        namespace _type {
+            namespace derived {
+                type value = Guaranteed_Value_Selection_;
+            }
+            type derived = {
+                readonly 'value': derived.value;
+            };
+            namespace selected {
+                type definition = Type_Node_.reference._type.selected;
+                type lookup = Lookup_Selection_;
+                type constraints = Property_Constraints_;
+            }
+            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_group {
+        type definition = Type_Node_.state_group;
+        namespace states {
+            namespace D {
+                type constraints = Option_Constraints_;
+                type resolver = Node_Resolver_;
+            }
+            type D = {
+                readonly 'constraints': D.constraints;
+                readonly 'resolver': D.resolver;
+            };
+        }
+        type states = _pi.Dictionary<states.D>;
+    }
+    type state_group = {
+        readonly 'definition': state_group.definition;
+        readonly 'states': state_group.states;
+    };
+    type text = null;
+}
+export type Node_Resolver_ = readonly ['boolean', Node_Resolver_._boolean] | readonly ['component', Node_Resolver_.component] | readonly ['dictionary', Node_Resolver_.dictionary] | readonly ['group', Node_Resolver_.group] | readonly ['list', Node_Resolver_.list] | readonly ['nothing', Node_Resolver_.nothing] | readonly ['number', Node_Resolver_._number] | readonly ['optional', Node_Resolver_.optional] | readonly ['reference', Node_Resolver_.reference] | readonly ['state group', Node_Resolver_.state_group] | readonly ['text', Node_Resolver_.text];
+export declare namespace Guaranteed_Value_Selection_ {
+    namespace start {
+        namespace sibling {
+            type entry = Node_Resolver_Group_.D;
+            type key = string;
+        }
+        type sibling = {
+            readonly 'entry': sibling.entry;
+            readonly 'key': sibling.key;
+        };
+        namespace parent_sibling {
+            type entry = Node_Resolver_Group_.D;
+            type key = string;
+        }
+        type parent_sibling = {
+            readonly 'entry': parent_sibling.entry;
+            readonly 'key': parent_sibling.key;
+        };
+        namespace option_constraint {
+            type entry = Option_Constraints_.D;
+            type key = string;
+        }
+        type option_constraint = {
+            readonly 'entry': option_constraint.entry;
+            readonly 'key': option_constraint.key;
+        };
+        type list_cursor = null;
+        type linked_entry = null;
+        namespace constraint {
+            namespace component {
+                namespace property {
+                    type entry = Node_Resolver_Group_.D;
+                    type key = string;
+                }
+                type property = {
+                    readonly 'entry': property.entry;
+                    readonly 'key': property.key;
+                };
+                namespace constraint {
+                    type entry = Property_Constraints_.D;
+                    type key = string;
+                }
+                type constraint = {
+                    readonly 'entry': constraint.entry;
+                    readonly 'key': constraint.key;
+                };
+            }
+            type component = {
+                readonly 'property': component.property;
+                readonly 'constraint': component.constraint;
+            };
+            namespace reference {
+                namespace property {
+                    type entry = Node_Resolver_Group_.D;
+                    type key = string;
+                }
+                type property = {
+                    readonly 'entry': property.entry;
+                    readonly 'key': property.key;
+                };
+                namespace constraint {
+                    type entry = Property_Constraints_.D;
+                    type key = string;
+                }
+                type constraint = {
+                    readonly 'entry': constraint.entry;
+                    readonly 'key': constraint.key;
+                };
+            }
+            type reference = {
+                readonly 'property': reference.property;
+                readonly 'constraint': reference.constraint;
+            };
+        }
+        type constraint = readonly ['component', constraint.component] | readonly ['reference', constraint.reference];
+        namespace parameter {
+            type entry = Signature_Parameters_.values.D;
+            type key = string;
+        }
+        type parameter = {
+            readonly 'entry': parameter.entry;
+            readonly 'key': parameter.key;
+        };
+        namespace result {
+            namespace list {
+                namespace property {
+                    type entry = Node_Resolver_Group_.D;
+                    type key = string;
+                }
+                type property = {
+                    readonly 'entry': property.entry;
+                    readonly 'key': property.key;
+                };
+                type list_result = Node_Resolver_.list.result.O;
+            }
+            type list = {
+                readonly 'property': list.property;
+                readonly 'list result': list.list_result;
+            };
+            namespace state_group {
+                namespace property {
+                    type entry = Node_Resolver_Group_.D;
+                    type key = string;
+                }
+                type property = {
+                    readonly 'entry': property.entry;
+                    readonly 'key': property.key;
+                };
+                type state_group = Node_Resolver_.state_group;
+                type result = Type_Reference_;
+            }
+            type state_group = {
+                readonly 'property': state_group.property;
+                readonly 'state group': state_group.state_group;
+                readonly 'result': state_group.result;
+            };
+            namespace optional_value {
+                namespace property {
+                    type entry = Node_Resolver_Group_.D;
+                    type key = string;
+                }
+                type property = {
+                    readonly 'entry': property.entry;
+                    readonly 'key': property.key;
+                };
+                type optional_value = Node_Resolver_.optional;
+                type result = Type_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 group', result.state_group] | 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 = Type_Node_;
+}
+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 entry = Signature_Parameters_.values.D;
+        type key = string;
+    }
+    type parameter = {
+        readonly 'entry': parameter.entry;
+        readonly 'key': parameter.key;
+    };
+    namespace result {
+        namespace state_group {
+            namespace property {
+                type entry = Node_Resolver_Group_.D;
+                type key = string;
+            }
+            type property = {
+                readonly 'entry': property.entry;
+                readonly 'key': property.key;
+            };
+            type state_group = Node_Resolver_.state_group;
+            type result = Type_Reference_;
+        }
+        type state_group = {
+            readonly 'property': state_group.property;
+            readonly 'state group': state_group.state_group;
+            readonly 'result': state_group.result;
+        };
+        namespace optional_value {
+            namespace property {
+                type entry = Node_Resolver_Group_.D;
+                type key = string;
+            }
+            type property = {
+                readonly 'entry': property.entry;
+                readonly 'key': property.key;
+            };
+            type optional_value = Node_Resolver_.optional;
+            type result = Type_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 group', result.state_group] | readonly ['optional value', result.optional_value];
+}
+export type Possible_Value_Selection_ = readonly ['parameter', Possible_Value_Selection_.parameter] | readonly ['result', Possible_Value_Selection_.result];
+export { Text_Type_ as Text_Type, Number_Type_ as Number_Type, Globals_ as Globals, Type_Parameters_ as Type_Parameters, Type_ as Type, Types_ as Types, Resolve_Logic_ as Resolve_Logic, Schema_ as Schema, Schema_Tree_ as Schema_Tree, Type_Specification_ as Type_Specification, Schemas_ as Schemas, Imports_ as Imports, Presence_ as Presence, Dictionary_ as Dictionary, Signatures_ as Signatures, Resolvers_ as Resolvers, Group_ as Group, Type_Node_ as Type_Node, Type_Reference_ as Type_Reference, Type_Node_Reference_ as Type_Node_Reference, Signature_Parameters_ as Signature_Parameters, Signature_ as Signature, Relative_Value_Selection_ as Relative_Value_Selection, Lookup_Selection_ as Lookup_Selection, Constraint_ as Constraint, Option_Constraints_ as Option_Constraints, Property_Constraints_ as Property_Constraints, Reference_To_Property_Constraint_ as Reference_To_Property_Constraint, Property_Constraint_ as Property_Constraint, Optional_Value_Initialization_ as Optional_Value_Initialization, Node_Resolver_Group_ as Node_Resolver_Group, Node_Resolver_List_Result_ as Node_Resolver_List_Result, Benchmark_ as Benchmark, Node_Resolver_ as Node_Resolver, Guaranteed_Value_Selection_ as Guaranteed_Value_Selection, Possible_Value_Selection_ as Possible_Value_Selection, };