pareto 0.80.74 → 0.80.76

package/dist/modules/implementation_old/schemas/unresolved/schema.d.ts

@@ -1,1288 +0,0 @@
-import * as p_di from 'pareto-core/schema';
-import * as i_location from "astn-core/modules/deserialization/schemas/location/schema";
-import * as i_imports_interface from "../../../interface_old/schemas/unresolved/schema.js";
-export declare namespace Package_Set_ {
-    type l_location = i_location.Range;
-    namespace l_dictionary {
-        namespace D {
-            type l_location = i_location.Range;
-            namespace l_entry {
-                type l_location = i_location.Range;
-                namespace l_state {
-                    type package_ = Package_;
-                    type set_ = Package_Set_;
-                }
-                type l_state = readonly ['package', l_state.package_] | readonly ['set', l_state.set_];
-            }
-            type l_entry = {
-                readonly 'l location': l_entry.l_location;
-                readonly 'l state': l_entry.l_state;
-            };
-        }
-        type D = {
-            readonly 'l location': D.l_location;
-            readonly 'l entry': D.l_entry;
-        };
-    }
-    type l_dictionary = p_di.Dictionary<l_dictionary.D>;
-}
-export type Package_Set_ = {
-    readonly 'l location': Package_Set_.l_location;
-    readonly 'l dictionary': Package_Set_.l_dictionary;
-};
-export declare namespace Package_ {
-    namespace specials {
-        type abort = boolean;
-        type change_context = boolean;
-        type implement_me = boolean;
-        type iterate = boolean;
-        type lookups = boolean;
-        type list_from_text = boolean;
-        type text_from_list = boolean;
-        type unreachable_code_path = boolean;
-        type variables = boolean;
-    }
-    type specials = {
-        readonly 'abort': specials.abort;
-        readonly 'change context': specials.change_context;
-        readonly 'implement me': specials.implement_me;
-        readonly 'iterate': specials.iterate;
-        readonly 'lookups': specials.lookups;
-        readonly 'list from text': specials.list_from_text;
-        readonly 'text from list': specials.text_from_list;
-        readonly 'unreachable code path': specials.unreachable_code_path;
-        readonly 'variables': specials.variables;
-    };
-    type type_imports = i_imports_interface.Imports;
-    namespace variable_imports {
-        type l_location = i_location.Range;
-        namespace l_dictionary {
-            namespace D {
-                type l_location = i_location.Range;
-                namespace l_entry {
-                    namespace tail {
-                        type l_location = i_location.Range;
-                        namespace l_list {
-                            namespace L {
-                                type l_location = i_location.Range;
-                                type l_item = string;
-                            }
-                            type L = {
-                                readonly 'l location': L.l_location;
-                                readonly 'l item': L.l_item;
-                            };
-                        }
-                        type l_list = p_di.List<l_list.L>;
-                    }
-                    type tail = {
-                        readonly 'l location': tail.l_location;
-                        readonly 'l list': tail.l_list;
-                    };
-                    namespace type_ {
-                        type l_location = i_location.Range;
-                        namespace l_state {
-                            namespace ancestor {
-                                type dependency = string;
-                                type number_of_steps = number;
-                            }
-                            type ancestor = {
-                                readonly 'dependency': ancestor.dependency;
-                                readonly 'number of steps': ancestor.number_of_steps;
-                            };
-                            type external = string;
-                            type sibling = string;
-                        }
-                        type l_state = readonly ['ancestor', l_state.ancestor] | readonly ['external', l_state.external] | readonly ['sibling', l_state.sibling];
-                    }
-                    type type_ = {
-                        readonly 'l location': type_.l_location;
-                        readonly 'l state': type_.l_state;
-                    };
-                }
-                type l_entry = {
-                    readonly 'tail': l_entry.tail;
-                    readonly 'type': l_entry.type_;
-                };
-            }
-            type D = {
-                readonly 'l location': D.l_location;
-                readonly 'l entry': D.l_entry;
-            };
-        }
-        type l_dictionary = p_di.Dictionary<l_dictionary.D>;
-    }
-    type variable_imports = {
-        readonly 'l location': variable_imports.l_location;
-        readonly 'l dictionary': variable_imports.l_dictionary;
-    };
-    namespace functions {
-        type l_location = i_location.Range;
-        namespace l_dictionary {
-            namespace D {
-                type l_location = i_location.Range;
-                namespace l_entry {
-                    namespace type_ {
-                        type import_ = string;
-                        type type_ = string;
-                    }
-                    type type_ = {
-                        readonly 'import': type_.import_;
-                        readonly 'type': type_.type_;
-                    };
-                    type expression = Assign_;
-                    type temp_has_abort = boolean;
-                    type temp_has_lookups = boolean;
-                    type temp_has_parameters = boolean;
-                }
-                type l_entry = {
-                    readonly 'type': l_entry.type_;
-                    readonly 'expression': l_entry.expression;
-                    readonly 'temp has abort': l_entry.temp_has_abort;
-                    readonly 'temp has lookups': l_entry.temp_has_lookups;
-                    readonly 'temp has parameters': l_entry.temp_has_parameters;
-                };
-            }
-            type D = {
-                readonly 'l location': D.l_location;
-                readonly 'l entry': D.l_entry;
-            };
-        }
-        type l_dictionary = p_di.Dictionary<l_dictionary.D>;
-    }
-    type functions = {
-        readonly 'l location': functions.l_location;
-        readonly 'l dictionary': functions.l_dictionary;
-    };
-}
-export type Package_ = {
-    readonly 'specials': Package_.specials;
-    readonly 'type imports': Package_.type_imports;
-    readonly 'variable imports': Package_.variable_imports;
-    readonly 'functions': Package_.functions;
-};
-export declare namespace Temp_Value_Type_Specification_ {
-    namespace type_ {
-        type import_ = string;
-        type type_ = string;
-    }
-    type type_ = {
-        readonly 'import': type_.import_;
-        readonly 'type': type_.type_;
-    };
-    namespace sub_selection {
-        type l_location = i_location.Range;
-        namespace l_list {
-            namespace L {
-                type l_location = i_location.Range;
-                namespace l_item {
-                    type l_location = i_location.Range;
-                    namespace l_state {
-                        type dictionary = null;
-                        type group = string;
-                        type list = null;
-                        type optional = null;
-                        type state = string;
-                    }
-                    type l_state = readonly ['dictionary', l_state.dictionary] | readonly ['group', l_state.group] | readonly ['list', l_state.list] | readonly ['optional', l_state.optional] | readonly ['state', l_state.state];
-                }
-                type l_item = {
-                    readonly 'l location': l_item.l_location;
-                    readonly 'l state': l_item.l_state;
-                };
-            }
-            type L = {
-                readonly 'l location': L.l_location;
-                readonly 'l item': L.l_item;
-            };
-        }
-        type l_list = p_di.List<l_list.L>;
-    }
-    type sub_selection = {
-        readonly 'l location': sub_selection.l_location;
-        readonly 'l list': sub_selection.l_list;
-    };
-}
-export type Temp_Value_Type_Specification_ = {
-    readonly 'type': Temp_Value_Type_Specification_.type_;
-    readonly 'sub selection': Temp_Value_Type_Specification_.sub_selection;
-};
-export declare namespace Assign_ {
-    type l_location = i_location.Range;
-    namespace l_state {
-        namespace decide {
-            type source = Select_Value_;
-            namespace type_ {
-                type l_location = i_location.Range;
-                namespace l_state {
-                    namespace boolean_ {
-                        namespace temp_resulting_node {
-                            type O = Temp_Value_Type_Specification_;
-                        }
-                        type temp_resulting_node = p_di.Optional_Value<temp_resulting_node.O>;
-                        type if_false = Assign_;
-                        type if_true = Assign_;
-                    }
-                    type boolean_ = {
-                        readonly 'temp resulting node': boolean_.temp_resulting_node;
-                        readonly 'if false': boolean_.if_false;
-                        readonly 'if true': boolean_.if_true;
-                    };
-                    namespace optional {
-                        namespace temp_resulting_node {
-                            type O = Temp_Value_Type_Specification_;
-                        }
-                        type temp_resulting_node = p_di.Optional_Value<temp_resulting_node.O>;
-                        type if_not_set = Assign_;
-                        type if_set = Assign_;
-                    }
-                    type optional = {
-                        readonly 'temp resulting node': optional.temp_resulting_node;
-                        readonly 'if not set': optional.if_not_set;
-                        readonly 'if set': optional.if_set;
-                    };
-                    namespace state {
-                        namespace temp_resulting_node {
-                            type O = Temp_Value_Type_Specification_;
-                        }
-                        type temp_resulting_node = p_di.Optional_Value<temp_resulting_node.O>;
-                        namespace type_ {
-                            type l_location = i_location.Range;
-                            namespace l_state {
-                                namespace partial {
-                                    namespace options {
-                                        type l_location = i_location.Range;
-                                        namespace l_dictionary {
-                                            namespace D {
-                                                type l_location = i_location.Range;
-                                                type l_entry = Assign_;
-                                            }
-                                            type D = {
-                                                readonly 'l location': D.l_location;
-                                                readonly 'l entry': D.l_entry;
-                                            };
-                                        }
-                                        type l_dictionary = p_di.Dictionary<l_dictionary.D>;
-                                    }
-                                    type options = {
-                                        readonly 'l location': options.l_location;
-                                        readonly 'l dictionary': options.l_dictionary;
-                                    };
-                                    type default_ = Assign_;
-                                }
-                                type partial = {
-                                    readonly 'options': partial.options;
-                                    readonly 'default': partial.default_;
-                                };
-                                namespace full {
-                                    namespace options {
-                                        type l_location = i_location.Range;
-                                        namespace l_dictionary {
-                                            namespace D {
-                                                type l_location = i_location.Range;
-                                                type l_entry = Assign_;
-                                            }
-                                            type D = {
-                                                readonly 'l location': D.l_location;
-                                                readonly 'l entry': D.l_entry;
-                                            };
-                                        }
-                                        type l_dictionary = p_di.Dictionary<l_dictionary.D>;
-                                    }
-                                    type options = {
-                                        readonly 'l location': options.l_location;
-                                        readonly 'l dictionary': options.l_dictionary;
-                                    };
-                                }
-                                type full = {
-                                    readonly 'options': full.options;
-                                };
-                                namespace single {
-                                    type option = string;
-                                    type if_true = Assign_;
-                                    type if_false = Assign_;
-                                }
-                                type single = {
-                                    readonly 'option': single.option;
-                                    readonly 'if true': single.if_true;
-                                    readonly 'if false': single.if_false;
-                                };
-                            }
-                            type l_state = readonly ['partial', l_state.partial] | readonly ['full', l_state.full] | readonly ['single', l_state.single];
-                        }
-                        type type_ = {
-                            readonly 'l location': type_.l_location;
-                            readonly 'l state': type_.l_state;
-                        };
-                    }
-                    type state = {
-                        readonly 'temp resulting node': state.temp_resulting_node;
-                        readonly 'type': state.type_;
-                    };
-                    namespace text {
-                        namespace temp_resulting_node {
-                            type O = Temp_Value_Type_Specification_;
-                        }
-                        type temp_resulting_node = p_di.Optional_Value<temp_resulting_node.O>;
-                        namespace cases {
-                            type l_location = i_location.Range;
-                            namespace l_dictionary {
-                                namespace D {
-                                    type l_location = i_location.Range;
-                                    type l_entry = Assign_;
-                                }
-                                type D = {
-                                    readonly 'l location': D.l_location;
-                                    readonly 'l entry': D.l_entry;
-                                };
-                            }
-                            type l_dictionary = p_di.Dictionary<l_dictionary.D>;
-                        }
-                        type cases = {
-                            readonly 'l location': cases.l_location;
-                            readonly 'l dictionary': cases.l_dictionary;
-                        };
-                        type default_ = Assign_;
-                    }
-                    type text = {
-                        readonly 'temp resulting node': text.temp_resulting_node;
-                        readonly 'cases': text.cases;
-                        readonly 'default': text.default_;
-                    };
-                }
-                type l_state = readonly ['boolean', l_state.boolean_] | readonly ['optional', l_state.optional] | readonly ['state', l_state.state] | readonly ['text', l_state.text];
-            }
-            type type_ = {
-                readonly 'l location': type_.l_location;
-                readonly 'l state': type_.l_state;
-            };
-        }
-        type decide = {
-            readonly 'source': decide.source;
-            readonly 'type': decide.type_;
-        };
-        namespace construct {
-            type l_location = i_location.Range;
-            namespace l_state {
-                namespace boolean_ {
-                    type l_location = i_location.Range;
-                    namespace l_state {
-                        namespace literal {
-                            type l_location = i_location.Range;
-                            namespace l_state {
-                                type false_ = null;
-                                type true_ = null;
-                            }
-                            type l_state = readonly ['false', l_state.false_] | readonly ['true', l_state.true_];
-                        }
-                        type literal = {
-                            readonly 'l location': literal.l_location;
-                            readonly 'l state': literal.l_state;
-                        };
-                        namespace from_ {
-                            type selection = Select_Value_;
-                            namespace type_ {
-                                type l_location = i_location.Range;
-                                namespace l_state {
-                                    namespace boolean_ {
-                                        type l_location = i_location.Range;
-                                        namespace l_state {
-                                            type not = null;
-                                            type copy = null;
-                                        }
-                                        type l_state = readonly ['not', l_state.not] | readonly ['copy', l_state.copy];
-                                    }
-                                    type boolean_ = {
-                                        readonly 'l location': boolean_.l_location;
-                                        readonly 'l state': boolean_.l_state;
-                                    };
-                                    namespace dictionary {
-                                        type l_location = i_location.Range;
-                                        namespace l_state {
-                                            type is_empty = null;
-                                        }
-                                        type l_state = readonly ['is empty', l_state.is_empty];
-                                    }
-                                    type dictionary = {
-                                        readonly 'l location': dictionary.l_location;
-                                        readonly 'l state': dictionary.l_state;
-                                    };
-                                    namespace list {
-                                        type l_location = i_location.Range;
-                                        namespace l_state {
-                                            type is_empty = null;
-                                        }
-                                        type l_state = readonly ['is empty', l_state.is_empty];
-                                    }
-                                    type list = {
-                                        readonly 'l location': list.l_location;
-                                        readonly 'l state': list.l_state;
-                                    };
-                                }
-                                type l_state = readonly ['boolean', l_state.boolean_] | readonly ['dictionary', l_state.dictionary] | readonly ['list', l_state.list];
-                            }
-                            type type_ = {
-                                readonly 'l location': type_.l_location;
-                                readonly 'l state': type_.l_state;
-                            };
-                        }
-                        type from_ = {
-                            readonly 'selection': from_.selection;
-                            readonly 'type': from_.type_;
-                        };
-                    }
-                    type l_state = readonly ['literal', l_state.literal] | readonly ['from', l_state.from_];
-                }
-                type boolean_ = {
-                    readonly 'l location': boolean_.l_location;
-                    readonly 'l state': boolean_.l_state;
-                };
-                namespace dictionary {
-                    type l_location = i_location.Range;
-                    namespace l_state {
-                        namespace literal {
-                            type l_location = i_location.Range;
-                            namespace l_dictionary {
-                                namespace D {
-                                    type l_location = i_location.Range;
-                                    type l_entry = Assign_;
-                                }
-                                type D = {
-                                    readonly 'l location': D.l_location;
-                                    readonly 'l entry': D.l_entry;
-                                };
-                            }
-                            type l_dictionary = p_di.Dictionary<l_dictionary.D>;
-                        }
-                        type literal = {
-                            readonly 'l location': literal.l_location;
-                            readonly 'l dictionary': literal.l_dictionary;
-                        };
-                        namespace from_ {
-                            type selection = Select_Value_;
-                            namespace type_ {
-                                type l_location = i_location.Range;
-                                namespace l_state {
-                                    namespace dictionary {
-                                        type l_location = i_location.Range;
-                                        namespace l_state {
-                                            namespace filter {
-                                                type assign_entry = Assign_;
-                                            }
-                                            type filter = {
-                                                readonly 'assign entry': filter.assign_entry;
-                                            };
-                                            namespace map {
-                                                type assign_entry = Assign_;
-                                            }
-                                            type map = {
-                                                readonly 'assign entry': map.assign_entry;
-                                            };
-                                            namespace resolve {
-                                                type assign_entry = Assign_;
-                                                type temp_resulting_entry_node = Temp_Value_Type_Specification_;
-                                            }
-                                            type resolve = {
-                                                readonly 'assign entry': resolve.assign_entry;
-                                                readonly 'temp resulting entry node': resolve.temp_resulting_entry_node;
-                                            };
-                                        }
-                                        type l_state = readonly ['filter', l_state.filter] | readonly ['map', l_state.map] | readonly ['resolve', l_state.resolve];
-                                    }
-                                    type dictionary = {
-                                        readonly 'l location': dictionary.l_location;
-                                        readonly 'l state': dictionary.l_state;
-                                    };
-                                    namespace list {
-                                        type l_location = i_location.Range;
-                                        namespace l_state {
-                                            namespace convert {
-                                                type assign_id = Assign_;
-                                                type assign_entry = Assign_;
-                                                type abort = Assign_;
-                                            }
-                                            type convert = {
-                                                readonly 'assign id': convert.assign_id;
-                                                readonly 'assign entry': convert.assign_entry;
-                                                readonly 'abort': convert.abort;
-                                            };
-                                        }
-                                        type l_state = readonly ['convert', l_state.convert];
-                                    }
-                                    type list = {
-                                        readonly 'l location': list.l_location;
-                                        readonly 'l state': list.l_state;
-                                    };
-                                }
-                                type l_state = readonly ['dictionary', l_state.dictionary] | readonly ['list', l_state.list];
-                            }
-                            type type_ = {
-                                readonly 'l location': type_.l_location;
-                                readonly 'l state': type_.l_state;
-                            };
-                        }
-                        type from_ = {
-                            readonly 'selection': from_.selection;
-                            readonly 'type': from_.type_;
-                        };
-                    }
-                    type l_state = readonly ['literal', l_state.literal] | readonly ['from', l_state.from_];
-                }
-                type dictionary = {
-                    readonly 'l location': dictionary.l_location;
-                    readonly 'l state': dictionary.l_state;
-                };
-                namespace group {
-                    type l_location = i_location.Range;
-                    namespace l_state {
-                        namespace literal {
-                            namespace properties {
-                                type l_location = i_location.Range;
-                                namespace l_dictionary {
-                                    namespace D {
-                                        type l_location = i_location.Range;
-                                        type l_entry = Assign_;
-                                    }
-                                    type D = {
-                                        readonly 'l location': D.l_location;
-                                        readonly 'l entry': D.l_entry;
-                                    };
-                                }
-                                type l_dictionary = p_di.Dictionary<l_dictionary.D>;
-                            }
-                            type properties = {
-                                readonly 'l location': properties.l_location;
-                                readonly 'l dictionary': properties.l_dictionary;
-                            };
-                            type have_dependencies = boolean;
-                        }
-                        type literal = {
-                            readonly 'properties': literal.properties;
-                            readonly 'have dependencies': literal.have_dependencies;
-                        };
-                    }
-                    type l_state = readonly ['literal', l_state.literal];
-                }
-                type group = {
-                    readonly 'l location': group.l_location;
-                    readonly 'l state': group.l_state;
-                };
-                namespace list {
-                    type l_location = i_location.Range;
-                    namespace l_state {
-                        namespace literal {
-                            type l_location = i_location.Range;
-                            namespace l_list {
-                                namespace L {
-                                    type l_location = i_location.Range;
-                                    type l_item = Assign_;
-                                }
-                                type L = {
-                                    readonly 'l location': L.l_location;
-                                    readonly 'l item': L.l_item;
-                                };
-                            }
-                            type l_list = p_di.List<l_list.L>;
-                        }
-                        type literal = {
-                            readonly 'l location': literal.l_location;
-                            readonly 'l list': literal.l_list;
-                        };
-                        namespace from_ {
-                            type selection = Select_Value_;
-                            namespace type_ {
-                                type l_location = i_location.Range;
-                                namespace l_state {
-                                    namespace dictionary {
-                                        type l_location = i_location.Range;
-                                        namespace l_state {
-                                            namespace convert {
-                                                type assign_entry = Assign_;
-                                            }
-                                            type convert = {
-                                                readonly 'assign entry': convert.assign_entry;
-                                            };
-                                        }
-                                        type l_state = readonly ['convert', l_state.convert];
-                                    }
-                                    type dictionary = {
-                                        readonly 'l location': dictionary.l_location;
-                                        readonly 'l state': dictionary.l_state;
-                                    };
-                                    namespace list {
-                                        type l_location = i_location.Range;
-                                        namespace l_state {
-                                            namespace filter {
-                                                type assign_item = Assign_;
-                                            }
-                                            type filter = {
-                                                readonly 'assign item': filter.assign_item;
-                                            };
-                                            namespace map {
-                                                type assign_item = Assign_;
-                                            }
-                                            type map = {
-                                                readonly 'assign item': map.assign_item;
-                                            };
-                                            namespace map_with_state {
-                                                type initialize_state = Assign_;
-                                                type assign_item = Assign_;
-                                                type update_state = Assign_;
-                                                type wrap_up = Assign_;
-                                            }
-                                            type map_with_state = {
-                                                readonly 'initialize state': map_with_state.initialize_state;
-                                                readonly 'assign item': map_with_state.assign_item;
-                                                readonly 'update state': map_with_state.update_state;
-                                                readonly 'wrap up': map_with_state.wrap_up;
-                                            };
-                                            namespace reduce {
-                                                type initialize_state = Assign_;
-                                                type assign_item = Assign_;
-                                            }
-                                            type reduce = {
-                                                readonly 'initialize state': reduce.initialize_state;
-                                                readonly 'assign item': reduce.assign_item;
-                                            };
-                                            type reverse = null;
-                                        }
-                                        type l_state = readonly ['filter', l_state.filter] | readonly ['map', l_state.map] | readonly ['map with state', l_state.map_with_state] | readonly ['reduce', l_state.reduce] | readonly ['reverse', l_state.reverse];
-                                    }
-                                    type list = {
-                                        readonly 'l location': list.l_location;
-                                        readonly 'l state': list.l_state;
-                                    };
-                                }
-                                type l_state = readonly ['dictionary', l_state.dictionary] | readonly ['list', l_state.list];
-                            }
-                            type type_ = {
-                                readonly 'l location': type_.l_location;
-                                readonly 'l state': type_.l_state;
-                            };
-                        }
-                        type from_ = {
-                            readonly 'selection': from_.selection;
-                            readonly 'type': from_.type_;
-                        };
-                    }
-                    type l_state = readonly ['literal', l_state.literal] | readonly ['from', l_state.from_];
-                }
-                type list = {
-                    readonly 'l location': list.l_location;
-                    readonly 'l state': list.l_state;
-                };
-                type nothing = null;
-                namespace number_ {
-                    type l_location = i_location.Range;
-                    namespace l_state {
-                        namespace approximation {
-                            type l_location = i_location.Range;
-                            namespace l_state {
-                                type literal = number;
-                                type copy = Select_Value_;
-                            }
-                            type l_state = readonly ['literal', l_state.literal] | readonly ['copy', l_state.copy];
-                        }
-                        type approximation = {
-                            readonly 'l location': approximation.l_location;
-                            readonly 'l state': approximation.l_state;
-                        };
-                        namespace integer {
-                            type l_location = i_location.Range;
-                            namespace l_state {
-                                type copy = Select_Value_;
-                                namespace divide {
-                                    type assign_dividend = Select_Value_;
-                                    type assign_divisor = Select_Value_;
-                                    type abort = Assign_;
-                                }
-                                type divide = {
-                                    readonly 'assign dividend': divide.assign_dividend;
-                                    readonly 'assign divisor': divide.assign_divisor;
-                                    readonly 'abort': divide.abort;
-                                };
-                                type literal = number;
-                            }
-                            type l_state = readonly ['copy', l_state.copy] | readonly ['divide', l_state.divide] | readonly ['literal', l_state.literal];
-                        }
-                        type integer = {
-                            readonly 'l location': integer.l_location;
-                            readonly 'l state': integer.l_state;
-                        };
-                        namespace natural {
-                            type l_location = i_location.Range;
-                            namespace l_state {
-                                type literal = number;
-                                type copy = Select_Value_;
-                                namespace number_of_dictionary_entries {
-                                    type dictionary = Select_Value_;
-                                }
-                                type number_of_dictionary_entries = {
-                                    readonly 'dictionary': number_of_dictionary_entries.dictionary;
-                                };
-                                namespace number_of_list_items {
-                                    type list = Select_Value_;
-                                }
-                                type number_of_list_items = {
-                                    readonly 'list': number_of_list_items.list;
-                                };
-                                type source_column = null;
-                                type source_line = null;
-                            }
-                            type l_state = readonly ['literal', l_state.literal] | readonly ['copy', l_state.copy] | readonly ['number of dictionary entries', l_state.number_of_dictionary_entries] | readonly ['number of list items', l_state.number_of_list_items] | readonly ['source column', l_state.source_column] | readonly ['source line', l_state.source_line];
-                        }
-                        type natural = {
-                            readonly 'l location': natural.l_location;
-                            readonly 'l state': natural.l_state;
-                        };
-                    }
-                    type l_state = readonly ['approximation', l_state.approximation] | readonly ['integer', l_state.integer] | readonly ['natural', l_state.natural];
-                }
-                type number_ = {
-                    readonly 'l location': number_.l_location;
-                    readonly 'l state': number_.l_state;
-                };
-                namespace optional {
-                    type l_location = i_location.Range;
-                    namespace l_state {
-                        namespace literal {
-                            type l_location = i_location.Range;
-                            namespace l_state {
-                                type not_set = null;
-                                type set_ = Assign_;
-                            }
-                            type l_state = readonly ['not set', l_state.not_set] | readonly ['set', l_state.set_];
-                        }
-                        type literal = {
-                            readonly 'l location': literal.l_location;
-                            readonly 'l state': literal.l_state;
-                        };
-                        namespace from_ {
-                            type selection = Select_Value_;
-                            namespace type_ {
-                                type l_location = i_location.Range;
-                                namespace l_state {
-                                    namespace boolean_ {
-                                        type l_location = i_location.Range;
-                                        namespace l_state {
-                                            namespace convert {
-                                                type assign_set = Assign_;
-                                            }
-                                            type convert = {
-                                                readonly 'assign set': convert.assign_set;
-                                            };
-                                        }
-                                        type l_state = readonly ['convert', l_state.convert];
-                                    }
-                                    type boolean_ = {
-                                        readonly 'l location': boolean_.l_location;
-                                        readonly 'l state': boolean_.l_state;
-                                    };
-                                    namespace optional {
-                                        type l_location = i_location.Range;
-                                        namespace l_state {
-                                            namespace map {
-                                                type assign_set = Assign_;
-                                            }
-                                            type map = {
-                                                readonly 'assign set': map.assign_set;
-                                            };
-                                        }
-                                        type l_state = readonly ['map', l_state.map];
-                                    }
-                                    type optional = {
-                                        readonly 'l location': optional.l_location;
-                                        readonly 'l state': optional.l_state;
-                                    };
-                                }
-                                type l_state = readonly ['boolean', l_state.boolean_] | readonly ['optional', l_state.optional];
-                            }
-                            type type_ = {
-                                readonly 'l location': type_.l_location;
-                                readonly 'l state': type_.l_state;
-                            };
-                        }
-                        type from_ = {
-                            readonly 'selection': from_.selection;
-                            readonly 'type': from_.type_;
-                        };
-                    }
-                    type l_state = readonly ['literal', l_state.literal] | readonly ['from', l_state.from_];
-                }
-                type optional = {
-                    readonly 'l location': optional.l_location;
-                    readonly 'l state': optional.l_state;
-                };
-                namespace state {
-                    type l_location = i_location.Range;
-                    namespace l_state {
-                        namespace literal {
-                            type option = string;
-                            type assign_option = Assign_;
-                        }
-                        type literal = {
-                            readonly 'option': literal.option;
-                            readonly 'assign option': literal.assign_option;
-                        };
-                    }
-                    type l_state = readonly ['literal', l_state.literal];
-                }
-                type state = {
-                    readonly 'l location': state.l_location;
-                    readonly 'l state': state.l_state;
-                };
-                namespace text {
-                    type l_location = i_location.Range;
-                    namespace l_state {
-                        namespace literal {
-                            namespace type_ {
-                                type l_location = i_location.Range;
-                                namespace l_state {
-                                    type identifier = null;
-                                    type freeform = null;
-                                }
-                                type l_state = readonly ['identifier', l_state.identifier] | readonly ['freeform', l_state.freeform];
-                            }
-                            type type_ = {
-                                readonly 'l location': type_.l_location;
-                                readonly 'l state': type_.l_state;
-                            };
-                            type value = string;
-                        }
-                        type literal = {
-                            readonly 'type': literal.type_;
-                            readonly 'value': literal.value;
-                        };
-                        namespace from_ {
-                            type selection = Select_Value_;
-                            namespace type_ {
-                                type l_location = i_location.Range;
-                                namespace l_state {
-                                    namespace text {
-                                        type l_location = i_location.Range;
-                                        namespace l_state {
-                                            type copy = null;
-                                        }
-                                        type l_state = readonly ['copy', l_state.copy];
-                                    }
-                                    type text = {
-                                        readonly 'l location': text.l_location;
-                                        readonly 'l state': text.l_state;
-                                    };
-                                }
-                                type l_state = readonly ['text', l_state.text];
-                            }
-                            type type_ = {
-                                readonly 'l location': type_.l_location;
-                                readonly 'l state': type_.l_state;
-                            };
-                        }
-                        type from_ = {
-                            readonly 'selection': from_.selection;
-                            readonly 'type': from_.type_;
-                        };
-                        type source_document = null;
-                        type entry_id = null;
-                        type option_name = null;
-                    }
-                    type l_state = readonly ['literal', l_state.literal] | readonly ['from', l_state.from_] | readonly ['source document', l_state.source_document] | readonly ['entry id', l_state.entry_id] | readonly ['option name', l_state.option_name];
-                }
-                type text = {
-                    readonly 'l location': text.l_location;
-                    readonly 'l state': text.l_state;
-                };
-            }
-            type l_state = readonly ['boolean', l_state.boolean_] | readonly ['dictionary', l_state.dictionary] | readonly ['group', l_state.group] | readonly ['list', l_state.list] | readonly ['nothing', l_state.nothing] | readonly ['number', l_state.number_] | readonly ['optional', l_state.optional] | readonly ['state', l_state.state] | readonly ['text', l_state.text];
-        }
-        type construct = {
-            readonly 'l location': construct.l_location;
-            readonly 'l state': construct.l_state;
-        };
-        type select = Select_Value_;
-        namespace special {
-            type l_location = i_location.Range;
-            namespace l_state {
-                type abort = Assign_;
-                namespace assert {
-                    type tester = Assign_;
-                    type normal_flow = Assign_;
-                }
-                type assert = {
-                    readonly 'tester': assert.tester;
-                    readonly 'normal flow': assert.normal_flow;
-                };
-                namespace change_context {
-                    type new_context = Select_Value_;
-                    type expression = Assign_;
-                }
-                type change_context = {
-                    readonly 'new context': change_context.new_context;
-                    readonly 'expression': change_context.expression;
-                };
-                namespace variables {
-                    namespace variables {
-                        type l_location = i_location.Range;
-                        namespace l_dictionary {
-                            namespace D {
-                                type l_location = i_location.Range;
-                                type l_entry = Assign_;
-                            }
-                            type D = {
-                                readonly 'l location': D.l_location;
-                                readonly 'l entry': D.l_entry;
-                            };
-                        }
-                        type l_dictionary = p_di.Dictionary<l_dictionary.D>;
-                    }
-                    type variables = {
-                        readonly 'l location': variables.l_location;
-                        readonly 'l dictionary': variables.l_dictionary;
-                    };
-                    type assign = Assign_;
-                }
-                type variables = {
-                    readonly 'variables': variables.variables;
-                    readonly 'assign': variables.assign;
-                };
-                type implement_me = string;
-                namespace iterate {
-                    type list = Select_Value_;
-                    type assign = Assign_;
-                }
-                type iterate = {
-                    readonly 'list': iterate.list;
-                    readonly 'assign': iterate.assign;
-                };
-                namespace unreachable {
-                    type explanation = string;
-                }
-                type unreachable = {
-                    readonly 'explanation': unreachable.explanation;
-                };
-            }
-            type l_state = readonly ['abort', l_state.abort] | readonly ['assert', l_state.assert] | readonly ['change context', l_state.change_context] | readonly ['variables', l_state.variables] | readonly ['implement me', l_state.implement_me] | readonly ['iterate', l_state.iterate] | readonly ['unreachable', l_state.unreachable];
-        }
-        type special = {
-            readonly 'l location': special.l_location;
-            readonly 'l state': special.l_state;
-        };
-    }
-    type l_state = readonly ['decide', l_state.decide] | readonly ['construct', l_state.construct] | readonly ['select', l_state.select] | readonly ['special', l_state.special];
-}
-export type Assign_ = {
-    readonly 'l location': Assign_.l_location;
-    readonly 'l state': Assign_.l_state;
-};
-export declare namespace Select_Value_ {
-    type l_location = i_location.Range;
-    namespace l_state {
-        type implement_me = string;
-        namespace regular {
-            namespace start {
-                type l_location = i_location.Range;
-                namespace l_state {
-                    namespace call {
-                        namespace source {
-                            type l_location = i_location.Range;
-                            namespace l_state {
-                                type local = string;
-                                namespace imported {
-                                    type import_ = string;
-                                    type variable = string;
-                                }
-                                type imported = {
-                                    readonly 'import': imported.import_;
-                                    readonly 'variable': imported.variable;
-                                };
-                            }
-                            type l_state = readonly ['local', l_state.local] | readonly ['imported', l_state.imported];
-                        }
-                        type source = {
-                            readonly 'l location': source.l_location;
-                            readonly 'l state': source.l_state;
-                        };
-                        type context = Assign_;
-                        namespace abort {
-                            type O = Assign_;
-                        }
-                        type abort = p_di.Optional_Value<abort.O>;
-                        namespace lookups {
-                            namespace O {
-                                type l_location = i_location.Range;
-                                namespace l_state {
-                                    namespace initialize {
-                                        type l_location = i_location.Range;
-                                        namespace l_dictionary {
-                                            namespace D {
-                                                type l_location = i_location.Range;
-                                                type l_entry = Select_Lookup_;
-                                            }
-                                            type D = {
-                                                readonly 'l location': D.l_location;
-                                                readonly 'l entry': D.l_entry;
-                                            };
-                                        }
-                                        type l_dictionary = p_di.Dictionary<l_dictionary.D>;
-                                    }
-                                    type initialize = {
-                                        readonly 'l location': initialize.l_location;
-                                        readonly 'l dictionary': initialize.l_dictionary;
-                                    };
-                                    type pass_through = null;
-                                }
-                                type l_state = readonly ['initialize', l_state.initialize] | readonly ['pass through', l_state.pass_through];
-                            }
-                            type O = {
-                                readonly 'l location': O.l_location;
-                                readonly 'l state': O.l_state;
-                            };
-                        }
-                        type lookups = p_di.Optional_Value<lookups.O>;
-                        namespace arguments_ {
-                            namespace O {
-                                type l_location = i_location.Range;
-                                namespace l_state {
-                                    namespace initialize {
-                                        type l_location = i_location.Range;
-                                        namespace l_dictionary {
-                                            namespace D {
-                                                type l_location = i_location.Range;
-                                                type l_entry = Assign_;
-                                            }
-                                            type D = {
-                                                readonly 'l location': D.l_location;
-                                                readonly 'l entry': D.l_entry;
-                                            };
-                                        }
-                                        type l_dictionary = p_di.Dictionary<l_dictionary.D>;
-                                    }
-                                    type initialize = {
-                                        readonly 'l location': initialize.l_location;
-                                        readonly 'l dictionary': initialize.l_dictionary;
-                                    };
-                                    type pass_through = null;
-                                }
-                                type l_state = readonly ['initialize', l_state.initialize] | readonly ['pass through', l_state.pass_through];
-                            }
-                            type O = {
-                                readonly 'l location': O.l_location;
-                                readonly 'l state': O.l_state;
-                            };
-                        }
-                        type arguments_ = p_di.Optional_Value<arguments_.O>;
-                    }
-                    type call = {
-                        readonly 'source': call.source;
-                        readonly 'context': call.context;
-                        readonly 'abort': call.abort;
-                        readonly 'lookups': call.lookups;
-                        readonly 'arguments': call.arguments_;
-                    };
-                    type context = null;
-                    namespace dictionary_entry {
-                        type dictionary = Select_Value_;
-                        type id = Assign_;
-                        type no_such_entry_handler = Assign_;
-                    }
-                    type dictionary_entry = {
-                        readonly 'dictionary': dictionary_entry.dictionary;
-                        readonly 'id': dictionary_entry.id;
-                        readonly 'no such entry handler': dictionary_entry.no_such_entry_handler;
-                    };
-                    namespace list_from_text {
-                        type source = Select_Value_;
-                        type assign_item = Assign_;
-                    }
-                    type list_from_text = {
-                        readonly 'source': list_from_text.source;
-                        readonly 'assign item': list_from_text.assign_item;
-                    };
-                    namespace lookup_entry {
-                        type lookup = Select_Lookup_;
-                        type id = Assign_;
-                        namespace type_ {
-                            type l_location = i_location.Range;
-                            namespace l_state {
-                                namespace acyclic {
-                                    namespace abort_handlers {
-                                        type no_such_entry = Assign_;
-                                        type no_context_lookup = Assign_;
-                                        type cycle_detected = Assign_;
-                                    }
-                                    type abort_handlers = {
-                                        readonly 'no such entry': abort_handlers.no_such_entry;
-                                        readonly 'no context lookup': abort_handlers.no_context_lookup;
-                                        readonly 'cycle detected': abort_handlers.cycle_detected;
-                                    };
-                                }
-                                type acyclic = {
-                                    readonly 'abort handlers': acyclic.abort_handlers;
-                                };
-                                namespace cyclic {
-                                    namespace abort_handlers {
-                                        type no_such_entry = Assign_;
-                                        type no_context_lookup = Assign_;
-                                        type accessing_cyclic_sibling_before_it_is_resolved = Assign_;
-                                    }
-                                    type abort_handlers = {
-                                        readonly 'no such entry': abort_handlers.no_such_entry;
-                                        readonly 'no context lookup': abort_handlers.no_context_lookup;
-                                        readonly 'accessing cyclic sibling before it is resolved': abort_handlers.accessing_cyclic_sibling_before_it_is_resolved;
-                                    };
-                                }
-                                type cyclic = {
-                                    readonly 'abort handlers': cyclic.abort_handlers;
-                                };
-                                namespace stack {
-                                    namespace abort_handlers {
-                                        type no_such_entry = Assign_;
-                                        type no_context_lookup = Assign_;
-                                        type cycle_detected = Assign_;
-                                    }
-                                    type abort_handlers = {
-                                        readonly 'no such entry': abort_handlers.no_such_entry;
-                                        readonly 'no context lookup': abort_handlers.no_context_lookup;
-                                        readonly 'cycle detected': abort_handlers.cycle_detected;
-                                    };
-                                }
-                                type stack = {
-                                    readonly 'abort handlers': stack.abort_handlers;
-                                };
-                            }
-                            type l_state = readonly ['acyclic', l_state.acyclic] | readonly ['cyclic', l_state.cyclic] | readonly ['stack', l_state.stack];
-                        }
-                        type type_ = {
-                            readonly 'l location': type_.l_location;
-                            readonly 'l state': type_.l_state;
-                        };
-                    }
-                    type lookup_entry = {
-                        readonly 'lookup': lookup_entry.lookup;
-                        readonly 'id': lookup_entry.id;
-                        readonly 'type': lookup_entry.type_;
-                    };
-                    namespace lookup_entry_depth {
-                        type lookup = Select_Lookup_;
-                        type id = Assign_;
-                        namespace abort_handlers {
-                            type no_such_entry = Assign_;
-                            type no_context_lookup = Assign_;
-                            type cycle_detected = Assign_;
-                        }
-                        type abort_handlers = {
-                            readonly 'no such entry': abort_handlers.no_such_entry;
-                            readonly 'no context lookup': abort_handlers.no_context_lookup;
-                            readonly 'cycle detected': abort_handlers.cycle_detected;
-                        };
-                    }
-                    type lookup_entry_depth = {
-                        readonly 'lookup': lookup_entry_depth.lookup;
-                        readonly 'id': lookup_entry_depth.id;
-                        readonly 'abort handlers': lookup_entry_depth.abort_handlers;
-                    };
-                    type parameter = string;
-                    type parent_sibling = string;
-                    type sibling = string;
-                    type state = null;
-                    namespace text_from_list {
-                        type source = Select_Value_;
-                        type assign_character = Assign_;
-                    }
-                    type text_from_list = {
-                        readonly 'source': text_from_list.source;
-                        readonly 'assign character': text_from_list.assign_character;
-                    };
-                    type variable = string;
-                }
-                type l_state = readonly ['call', l_state.call] | readonly ['context', l_state.context] | readonly ['dictionary entry', l_state.dictionary_entry] | readonly ['list from text', l_state.list_from_text] | readonly ['lookup entry', l_state.lookup_entry] | readonly ['lookup entry depth', l_state.lookup_entry_depth] | readonly ['parameter', l_state.parameter] | readonly ['parent sibling', l_state.parent_sibling] | readonly ['sibling', l_state.sibling] | readonly ['state', l_state.state] | readonly ['text from list', l_state.text_from_list] | readonly ['variable', l_state.variable];
-            }
-            type start = {
-                readonly 'l location': start.l_location;
-                readonly 'l state': start.l_state;
-            };
-            namespace tail {
-                type l_location = i_location.Range;
-                namespace l_list {
-                    namespace L {
-                        type l_location = i_location.Range;
-                        type l_item = string;
-                    }
-                    type L = {
-                        readonly 'l location': L.l_location;
-                        readonly 'l item': L.l_item;
-                    };
-                }
-                type l_list = p_di.List<l_list.L>;
-            }
-            type tail = {
-                readonly 'l location': tail.l_location;
-                readonly 'l list': tail.l_list;
-            };
-        }
-        type regular = {
-            readonly 'start': regular.start;
-            readonly 'tail': regular.tail;
-        };
-    }
-    type l_state = readonly ['implement me', l_state.implement_me] | readonly ['regular', l_state.regular];
-}
-export type Select_Value_ = {
-    readonly 'l location': Select_Value_.l_location;
-    readonly 'l state': Select_Value_.l_state;
-};
-export declare namespace Select_Lookup_ {
-    type l_location = i_location.Range;
-    namespace l_state {
-        type implement_me = string;
-        type from_parameter = string;
-        namespace stack {
-            type l_location = i_location.Range;
-            namespace l_state {
-                type empty = null;
-                namespace push {
-                    type stack = Select_Lookup_;
-                    type acyclic = Select_Lookup_;
-                }
-                type push = {
-                    readonly 'stack': push.stack;
-                    readonly 'acyclic': push.acyclic;
-                };
-            }
-            type l_state = readonly ['empty', l_state.empty] | readonly ['push', l_state.push];
-        }
-        type stack = {
-            readonly 'l location': stack.l_location;
-            readonly 'l state': stack.l_state;
-        };
-        namespace acyclic {
-            type l_location = i_location.Range;
-            namespace l_state {
-                type not_set = null;
-                type siblings = null;
-                type resolved_dictionary = Select_Value_;
-            }
-            type l_state = readonly ['not set', l_state.not_set] | readonly ['siblings', l_state.siblings] | readonly ['resolved dictionary', l_state.resolved_dictionary];
-        }
-        type acyclic = {
-            readonly 'l location': acyclic.l_location;
-            readonly 'l state': acyclic.l_state;
-        };
-        namespace cyclic {
-            type l_location = i_location.Range;
-            namespace l_state {
-                type not_set = null;
-                type siblings = null;
-            }
-            type l_state = readonly ['not set', l_state.not_set] | readonly ['siblings', l_state.siblings];
-        }
-        type cyclic = {
-            readonly 'l location': cyclic.l_location;
-            readonly 'l state': cyclic.l_state;
-        };
-    }
-    type l_state = readonly ['implement me', l_state.implement_me] | readonly ['from parameter', l_state.from_parameter] | readonly ['stack', l_state.stack] | readonly ['acyclic', l_state.acyclic] | readonly ['cyclic', l_state.cyclic];
-}
-export type Select_Lookup_ = {
-    readonly 'l location': Select_Lookup_.l_location;
-    readonly 'l state': Select_Lookup_.l_state;
-};
-export type { Package_Set_ as Package_Set, Package_ as Package, Temp_Value_Type_Specification_ as Temp_Value_Type_Specification, Assign_ as Assign, Select_Value_ as Select_Value, Select_Lookup_ as Select_Lookup, };