pareto-liana 0.0.1 → 0.0.3

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

@@ -1,984 +0,0 @@
-import * as _pi from "pareto-core/dist/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;
-            readonly 'up steps': number;
-        };
-        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];
-            'referred': Type_Node_;
-        };
-    }
-    type tail = {
-        'list': _pi.List<tail.L>;
-        'referred': Type_Node_;
-    };
-    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];
-            'referred': Type_Node_;
-        };
-    }
-    type path = {
-        'list': _pi.List<path.L>;
-        'referred': Type_Node_;
-    };
-    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, };