pareto 0.80.74 → 0.80.76

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

@@ -1,748 +0,0 @@
-import * as p_di from 'pareto-core/schema';
-import * as i_imports_interface from "../../../interface_old/schemas/resolved/schema.js";
-export declare namespace Package_Set_ {
-    namespace D {
-        type package_ = Package_;
-        type set_ = Package_Set_;
-    }
-    type D = readonly ['package', D.package_] | readonly ['set', D.set_];
-}
-export type Package_Set_ = p_di.Dictionary<Package_Set_.D>;
-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 {
-        namespace D {
-            namespace tail {
-                type L = string;
-            }
-            type tail = p_di.List<tail.L>;
-            namespace type_ {
-                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 type_ = readonly ['ancestor', type_.ancestor] | readonly ['external', type_.external] | readonly ['sibling', type_.sibling];
-        }
-        type D = {
-            readonly 'tail': D.tail;
-            readonly 'type': D.type_;
-        };
-    }
-    type variable_imports = p_di.Dictionary<variable_imports.D>;
-    namespace functions {
-        namespace D {
-            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 D = {
-            readonly 'type': D.type_;
-            readonly 'expression': D.expression;
-            readonly 'temp has abort': D.temp_has_abort;
-            readonly 'temp has lookups': D.temp_has_lookups;
-            readonly 'temp has parameters': D.temp_has_parameters;
-        };
-    }
-    type functions = p_di.Dictionary<functions.D>;
-}
-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 {
-        namespace L {
-            type dictionary = null;
-            type group = string;
-            type list = null;
-            type optional = null;
-            type state = string;
-        }
-        type L = readonly ['dictionary', L.dictionary] | readonly ['group', L.group] | readonly ['list', L.list] | readonly ['optional', L.optional] | readonly ['state', L.state];
-    }
-    type sub_selection = p_di.List<sub_selection.L>;
-}
-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_ {
-    namespace decide {
-        type source = Select_Value_;
-        namespace type_ {
-            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_ {
-                    namespace partial {
-                        namespace options {
-                            type D = Assign_;
-                        }
-                        type options = p_di.Dictionary<options.D>;
-                        type default_ = Assign_;
-                    }
-                    type partial = {
-                        readonly 'options': partial.options;
-                        readonly 'default': partial.default_;
-                    };
-                    namespace full {
-                        namespace options {
-                            type D = Assign_;
-                        }
-                        type options = p_di.Dictionary<options.D>;
-                    }
-                    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 type_ = readonly ['partial', type_.partial] | readonly ['full', type_.full] | readonly ['single', type_.single];
-            }
-            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 D = Assign_;
-                }
-                type cases = p_di.Dictionary<cases.D>;
-                type default_ = Assign_;
-            }
-            type text = {
-                readonly 'temp resulting node': text.temp_resulting_node;
-                readonly 'cases': text.cases;
-                readonly 'default': text.default_;
-            };
-        }
-        type type_ = readonly ['boolean', type_.boolean_] | readonly ['optional', type_.optional] | readonly ['state', type_.state] | readonly ['text', type_.text];
-    }
-    type decide = {
-        readonly 'source': decide.source;
-        readonly 'type': decide.type_;
-    };
-    namespace construct {
-        namespace boolean_ {
-            namespace literal {
-                type false_ = null;
-                type true_ = null;
-            }
-            type literal = readonly ['false', literal.false_] | readonly ['true', literal.true_];
-            namespace from_ {
-                type selection = Select_Value_;
-                namespace type_ {
-                    namespace boolean_ {
-                        type not = null;
-                        type copy = null;
-                    }
-                    type boolean_ = readonly ['not', boolean_.not] | readonly ['copy', boolean_.copy];
-                    namespace dictionary {
-                        type is_empty = null;
-                    }
-                    type dictionary = readonly ['is empty', dictionary.is_empty];
-                    namespace list {
-                        type is_empty = null;
-                    }
-                    type list = readonly ['is empty', list.is_empty];
-                }
-                type type_ = readonly ['boolean', type_.boolean_] | readonly ['dictionary', type_.dictionary] | readonly ['list', type_.list];
-            }
-            type from_ = {
-                readonly 'selection': from_.selection;
-                readonly 'type': from_.type_;
-            };
-        }
-        type boolean_ = readonly ['literal', boolean_.literal] | readonly ['from', boolean_.from_];
-        namespace dictionary {
-            namespace literal {
-                type D = Assign_;
-            }
-            type literal = p_di.Dictionary<literal.D>;
-            namespace from_ {
-                type selection = Select_Value_;
-                namespace type_ {
-                    namespace dictionary {
-                        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 dictionary = readonly ['filter', dictionary.filter] | readonly ['map', dictionary.map] | readonly ['resolve', dictionary.resolve];
-                    namespace list {
-                        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 list = readonly ['convert', list.convert];
-                }
-                type type_ = readonly ['dictionary', type_.dictionary] | readonly ['list', type_.list];
-            }
-            type from_ = {
-                readonly 'selection': from_.selection;
-                readonly 'type': from_.type_;
-            };
-        }
-        type dictionary = readonly ['literal', dictionary.literal] | readonly ['from', dictionary.from_];
-        namespace group {
-            namespace literal {
-                namespace properties {
-                    type D = Assign_;
-                }
-                type properties = p_di.Dictionary<properties.D>;
-                type have_dependencies = boolean;
-            }
-            type literal = {
-                readonly 'properties': literal.properties;
-                readonly 'have dependencies': literal.have_dependencies;
-            };
-        }
-        type group = readonly ['literal', group.literal];
-        namespace list {
-            namespace literal {
-                type L = Assign_;
-            }
-            type literal = p_di.List<literal.L>;
-            namespace from_ {
-                type selection = Select_Value_;
-                namespace type_ {
-                    namespace dictionary {
-                        namespace convert {
-                            type assign_entry = Assign_;
-                        }
-                        type convert = {
-                            readonly 'assign entry': convert.assign_entry;
-                        };
-                    }
-                    type dictionary = readonly ['convert', dictionary.convert];
-                    namespace list {
-                        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 list = readonly ['filter', list.filter] | readonly ['map', list.map] | readonly ['map with state', list.map_with_state] | readonly ['reduce', list.reduce] | readonly ['reverse', list.reverse];
-                }
-                type type_ = readonly ['dictionary', type_.dictionary] | readonly ['list', type_.list];
-            }
-            type from_ = {
-                readonly 'selection': from_.selection;
-                readonly 'type': from_.type_;
-            };
-        }
-        type list = readonly ['literal', list.literal] | readonly ['from', list.from_];
-        type nothing = null;
-        namespace number_ {
-            namespace approximation {
-                type literal = number;
-                type copy = Select_Value_;
-            }
-            type approximation = readonly ['literal', approximation.literal] | readonly ['copy', approximation.copy];
-            namespace integer {
-                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 integer = readonly ['copy', integer.copy] | readonly ['divide', integer.divide] | readonly ['literal', integer.literal];
-            namespace natural {
-                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 natural = readonly ['literal', natural.literal] | readonly ['copy', natural.copy] | readonly ['number of dictionary entries', natural.number_of_dictionary_entries] | readonly ['number of list items', natural.number_of_list_items] | readonly ['source column', natural.source_column] | readonly ['source line', natural.source_line];
-        }
-        type number_ = readonly ['approximation', number_.approximation] | readonly ['integer', number_.integer] | readonly ['natural', number_.natural];
-        namespace optional {
-            namespace literal {
-                type not_set = null;
-                type set_ = Assign_;
-            }
-            type literal = readonly ['not set', literal.not_set] | readonly ['set', literal.set_];
-            namespace from_ {
-                type selection = Select_Value_;
-                namespace type_ {
-                    namespace boolean_ {
-                        namespace convert {
-                            type assign_set = Assign_;
-                        }
-                        type convert = {
-                            readonly 'assign set': convert.assign_set;
-                        };
-                    }
-                    type boolean_ = readonly ['convert', boolean_.convert];
-                    namespace optional {
-                        namespace map {
-                            type assign_set = Assign_;
-                        }
-                        type map = {
-                            readonly 'assign set': map.assign_set;
-                        };
-                    }
-                    type optional = readonly ['map', optional.map];
-                }
-                type type_ = readonly ['boolean', type_.boolean_] | readonly ['optional', type_.optional];
-            }
-            type from_ = {
-                readonly 'selection': from_.selection;
-                readonly 'type': from_.type_;
-            };
-        }
-        type optional = readonly ['literal', optional.literal] | readonly ['from', optional.from_];
-        namespace state {
-            namespace literal {
-                type option = string;
-                type assign_option = Assign_;
-            }
-            type literal = {
-                readonly 'option': literal.option;
-                readonly 'assign option': literal.assign_option;
-            };
-        }
-        type state = readonly ['literal', state.literal];
-        namespace text {
-            namespace literal {
-                namespace type_ {
-                    type identifier = null;
-                    type freeform = null;
-                }
-                type type_ = readonly ['identifier', type_.identifier] | readonly ['freeform', type_.freeform];
-                type value = string;
-            }
-            type literal = {
-                readonly 'type': literal.type_;
-                readonly 'value': literal.value;
-            };
-            namespace from_ {
-                type selection = Select_Value_;
-                namespace type_ {
-                    namespace text {
-                        type copy = null;
-                    }
-                    type text = readonly ['copy', text.copy];
-                }
-                type type_ = readonly ['text', type_.text];
-            }
-            type from_ = {
-                readonly 'selection': from_.selection;
-                readonly 'type': from_.type_;
-            };
-            type source_document = null;
-            type entry_id = null;
-            type option_name = null;
-        }
-        type text = readonly ['literal', text.literal] | readonly ['from', text.from_] | readonly ['source document', text.source_document] | readonly ['entry id', text.entry_id] | readonly ['option name', text.option_name];
-    }
-    type construct = readonly ['boolean', construct.boolean_] | readonly ['dictionary', construct.dictionary] | readonly ['group', construct.group] | readonly ['list', construct.list] | readonly ['nothing', construct.nothing] | readonly ['number', construct.number_] | readonly ['optional', construct.optional] | readonly ['state', construct.state] | readonly ['text', construct.text];
-    type select = Select_Value_;
-    namespace special {
-        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 D = Assign_;
-            }
-            type variables = p_di.Dictionary<variables.D>;
-            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 special = readonly ['abort', special.abort] | readonly ['assert', special.assert] | readonly ['change context', special.change_context] | readonly ['variables', special.variables] | readonly ['implement me', special.implement_me] | readonly ['iterate', special.iterate] | readonly ['unreachable', special.unreachable];
-}
-export type Assign_ = readonly ['decide', Assign_.decide] | readonly ['construct', Assign_.construct] | readonly ['select', Assign_.select] | readonly ['special', Assign_.special];
-export declare namespace Select_Value_ {
-    type implement_me = string;
-    namespace regular {
-        namespace start {
-            namespace call {
-                namespace source {
-                    type local = string;
-                    namespace imported {
-                        type import_ = string;
-                        type variable = string;
-                    }
-                    type imported = {
-                        readonly 'import': imported.import_;
-                        readonly 'variable': imported.variable;
-                    };
-                }
-                type source = readonly ['local', source.local] | readonly ['imported', source.imported];
-                type context = Assign_;
-                namespace abort {
-                    type O = Assign_;
-                }
-                type abort = p_di.Optional_Value<abort.O>;
-                namespace lookups {
-                    namespace O {
-                        namespace initialize {
-                            type D = Select_Lookup_;
-                        }
-                        type initialize = p_di.Dictionary<initialize.D>;
-                        type pass_through = null;
-                    }
-                    type O = readonly ['initialize', O.initialize] | readonly ['pass through', O.pass_through];
-                }
-                type lookups = p_di.Optional_Value<lookups.O>;
-                namespace arguments_ {
-                    namespace O {
-                        namespace initialize {
-                            type D = Assign_;
-                        }
-                        type initialize = p_di.Dictionary<initialize.D>;
-                        type pass_through = null;
-                    }
-                    type O = readonly ['initialize', O.initialize] | readonly ['pass through', O.pass_through];
-                }
-                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_ {
-                    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 type_ = readonly ['acyclic', type_.acyclic] | readonly ['cyclic', type_.cyclic] | readonly ['stack', type_.stack];
-            }
-            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 start = readonly ['call', start.call] | readonly ['context', start.context] | readonly ['dictionary entry', start.dictionary_entry] | readonly ['list from text', start.list_from_text] | readonly ['lookup entry', start.lookup_entry] | readonly ['lookup entry depth', start.lookup_entry_depth] | readonly ['parameter', start.parameter] | readonly ['parent sibling', start.parent_sibling] | readonly ['sibling', start.sibling] | readonly ['state', start.state] | readonly ['text from list', start.text_from_list] | readonly ['variable', start.variable];
-        namespace tail {
-            type L = string;
-        }
-        type tail = p_di.List<tail.L>;
-    }
-    type regular = {
-        readonly 'start': regular.start;
-        readonly 'tail': regular.tail;
-    };
-}
-export type Select_Value_ = readonly ['implement me', Select_Value_.implement_me] | readonly ['regular', Select_Value_.regular];
-export declare namespace Select_Lookup_ {
-    type implement_me = string;
-    type from_parameter = string;
-    namespace stack {
-        type empty = null;
-        namespace push {
-            type stack = Select_Lookup_;
-            type acyclic = Select_Lookup_;
-        }
-        type push = {
-            readonly 'stack': push.stack;
-            readonly 'acyclic': push.acyclic;
-        };
-    }
-    type stack = readonly ['empty', stack.empty] | readonly ['push', stack.push];
-    namespace acyclic {
-        type not_set = null;
-        type siblings = null;
-        type resolved_dictionary = Select_Value_;
-    }
-    type acyclic = readonly ['not set', acyclic.not_set] | readonly ['siblings', acyclic.siblings] | readonly ['resolved dictionary', acyclic.resolved_dictionary];
-    namespace cyclic {
-        type not_set = null;
-        type siblings = null;
-    }
-    type cyclic = readonly ['not set', cyclic.not_set] | readonly ['siblings', cyclic.siblings];
-}
-export type Select_Lookup_ = readonly ['implement me', Select_Lookup_.implement_me] | readonly ['from parameter', Select_Lookup_.from_parameter] | readonly ['stack', Select_Lookup_.stack] | readonly ['acyclic', Select_Lookup_.acyclic] | readonly ['cyclic', Select_Lookup_.cyclic];
-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, };