astn 0.113.29 → 0.113.31

package/dist/interface/generated/pareto/schemas/astn_schema/data/unresolved.d.ts

@@ -0,0 +1,270 @@
+import * as _pi from "pareto-core-interface";
+import * as i__location from "../../../core/location";
+export declare namespace Schemas_ {
+    type location = i__location.Location;
+    namespace dictionary {
+        namespace D {
+            type location = i__location.Location;
+            type entry = Schema_Tree_;
+        }
+        type D = {
+            readonly 'location': D.location;
+            readonly 'entry': D.entry;
+        };
+    }
+    type dictionary = _pi.Dictionary<dictionary.D>;
+}
+export type Schemas_ = {
+    readonly 'location': Schemas_.location;
+    readonly 'dictionary': Schemas_.dictionary;
+};
+export declare namespace Text_Type_ {
+    namespace _type {
+        type location = i__location.Location;
+        namespace state_group {
+            type multi_line = null;
+            type single_line = null;
+        }
+        type state_group = readonly ['multi line', state_group.multi_line] | readonly ['single line', state_group.single_line];
+    }
+    type _type = {
+        readonly 'location': _type.location;
+        readonly 'state group': _type.state_group;
+    };
+}
+export type Text_Type_ = {
+    readonly 'type': Text_Type_._type;
+};
+export declare namespace Globals_ {
+    namespace text_types {
+        type location = i__location.Location;
+        namespace dictionary {
+            namespace D {
+                type location = i__location.Location;
+                type entry = Text_Type_;
+            }
+            type D = {
+                readonly 'location': D.location;
+                readonly 'entry': D.entry;
+            };
+        }
+        type dictionary = _pi.Dictionary<dictionary.D>;
+    }
+    type text_types = {
+        readonly 'location': text_types.location;
+        readonly 'dictionary': text_types.dictionary;
+    };
+}
+export type Globals_ = {
+    readonly 'text types': Globals_.text_types;
+};
+export declare namespace Type_ {
+    type node = Type_Node_;
+}
+export type Type_ = {
+    readonly 'node': Type_.node;
+};
+export declare namespace Types_ {
+    type location = i__location.Location;
+    namespace dictionary {
+        namespace D {
+            type location = i__location.Location;
+            type entry = Type_;
+        }
+        type D = {
+            readonly 'location': D.location;
+            readonly 'entry': D.entry;
+        };
+    }
+    type dictionary = _pi.Dictionary<dictionary.D>;
+}
+export type Types_ = {
+    readonly 'location': Types_.location;
+    readonly 'dictionary': Types_.dictionary;
+};
+export declare namespace Schema_ {
+    type imports = Imports_;
+    type globals = Globals_;
+    type types = Types_;
+}
+export type Schema_ = {
+    readonly 'imports': Schema_.imports;
+    readonly 'globals': Schema_.globals;
+    readonly 'types': Schema_.types;
+};
+export declare namespace Schema_Tree_ {
+    type location = i__location.Location;
+    namespace state_group {
+        type _set = Schemas_;
+        type schema = Schema_;
+    }
+    type state_group = readonly ['set', state_group._set] | readonly ['schema', state_group.schema];
+}
+export type Schema_Tree_ = {
+    readonly 'location': Schema_Tree_.location;
+    readonly 'state group': Schema_Tree_.state_group;
+};
+export declare namespace Imports_ {
+    type location = i__location.Location;
+    namespace dictionary {
+        namespace D {
+            type location = i__location.Location;
+            namespace entry {
+                namespace schema_set_child {
+                    type location = i__location.Location;
+                    type key = string;
+                }
+                type schema_set_child = {
+                    readonly 'location': schema_set_child.location;
+                    readonly 'key': schema_set_child.key;
+                };
+                type schema = null;
+            }
+            type entry = {
+                readonly 'schema set child': entry.schema_set_child;
+                readonly 'schema': entry.schema;
+            };
+        }
+        type D = {
+            readonly 'location': D.location;
+            readonly 'entry': D.entry;
+        };
+    }
+    type dictionary = _pi.Dictionary<dictionary.D>;
+}
+export type Imports_ = {
+    readonly 'location': Imports_.location;
+    readonly 'dictionary': Imports_.dictionary;
+};
+export declare namespace Dictionary_ {
+    type node = Type_Node_;
+    type ordered = boolean;
+}
+export type Dictionary_ = {
+    readonly 'node': Dictionary_.node;
+    readonly 'ordered': Dictionary_.ordered;
+};
+export declare namespace Group_ {
+    type location = i__location.Location;
+    namespace dictionary {
+        namespace D {
+            type location = i__location.Location;
+            type entry = Type_Node_;
+        }
+        type D = {
+            readonly 'location': D.location;
+            readonly 'entry': D.entry;
+        };
+    }
+    type dictionary = _pi.Dictionary<dictionary.D>;
+}
+export type Group_ = {
+    readonly 'location': Group_.location;
+    readonly 'dictionary': Group_.dictionary;
+};
+export declare namespace Type_Node_ {
+    type location = i__location.Location;
+    namespace state_group {
+        namespace component {
+            type location = i__location.Location;
+            namespace state_group {
+                namespace external {
+                    namespace _import {
+                        type location = i__location.Location;
+                        type key = string;
+                    }
+                    type _import = {
+                        readonly 'location': _import.location;
+                        readonly 'key': _import.key;
+                    };
+                    namespace _type {
+                        type location = i__location.Location;
+                        type key = string;
+                    }
+                    type _type = {
+                        readonly 'location': _type.location;
+                        readonly 'key': _type.key;
+                    };
+                }
+                type external = {
+                    readonly 'import': external._import;
+                    readonly 'type': external._type;
+                };
+                namespace internal {
+                    type location = i__location.Location;
+                    type key = string;
+                }
+                type internal = {
+                    readonly 'location': internal.location;
+                    readonly 'key': internal.key;
+                };
+                namespace internal_cyclic {
+                    type location = i__location.Location;
+                    type key = string;
+                }
+                type internal_cyclic = {
+                    readonly 'location': internal_cyclic.location;
+                    readonly 'key': internal_cyclic.key;
+                };
+            }
+            type state_group = readonly ['external', state_group.external] | readonly ['internal', state_group.internal] | readonly ['internal cyclic', state_group.internal_cyclic];
+        }
+        type component = {
+            readonly 'location': component.location;
+            readonly 'state group': component.state_group;
+        };
+        type dictionary = Dictionary_;
+        type group = Group_;
+        namespace list {
+            type node = Type_Node_;
+        }
+        type list = {
+            readonly 'node': list.node;
+        };
+        type nothing = null;
+        type optional = Type_Node_;
+        namespace state_group {
+            type location = i__location.Location;
+            namespace dictionary {
+                namespace D {
+                    type location = i__location.Location;
+                    type entry = Type_Node_;
+                }
+                type D = {
+                    readonly 'location': D.location;
+                    readonly 'entry': D.entry;
+                };
+            }
+            type dictionary = _pi.Dictionary<dictionary.D>;
+        }
+        type state_group = {
+            readonly 'location': state_group.location;
+            readonly 'dictionary': state_group.dictionary;
+        };
+        namespace text {
+            type location = i__location.Location;
+            namespace state_group {
+                namespace global {
+                    type location = i__location.Location;
+                    type key = string;
+                }
+                type global = {
+                    readonly 'location': global.location;
+                    readonly 'key': global.key;
+                };
+                type local = Text_Type_;
+            }
+            type state_group = readonly ['global', state_group.global] | readonly ['local', state_group.local];
+        }
+        type text = {
+            readonly 'location': text.location;
+            readonly 'state group': text.state_group;
+        };
+    }
+    type state_group = readonly ['component', state_group.component] | readonly ['dictionary', state_group.dictionary] | readonly ['group', state_group.group] | readonly ['list', state_group.list] | readonly ['nothing', state_group.nothing] | readonly ['optional', state_group.optional] | readonly ['state group', state_group.state_group] | readonly ['text', state_group.text];
+}
+export type Type_Node_ = {
+    readonly 'location': Type_Node_.location;
+    readonly 'state group': Type_Node_.state_group;
+};
+export { Schemas_ as Schemas, Text_Type_ as Text_Type, Globals_ as Globals, Type_ as Type, Types_ as Types, Schema_ as Schema, Schema_Tree_ as Schema_Tree, Imports_ as Imports, Dictionary_ as Dictionary, Group_ as Group, Type_Node_ as Type_Node, };

package/dist/interface/generated/pareto/schemas/astn_schema/data/unresolved.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5yZXNvbHZlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL2FzdG5fc2NoZW1hL2RhdGEvdW5yZXNvbHZlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/interface/generated/pareto/schemas/astn_schema/migrate_boilerplate.d.ts

@@ -1,5 +1,5 @@
-import * as i_out from "./data_types/target";
-import * as i_in from "./data_types/source";
+import * as i_out from "./data/unresolved";
+import * as i_in from "./data/resolved";
 export declare namespace Schemas_ {
     type I = i_in.Schemas;
     type O = i_out.Schemas;

package/dist/interface/generated/pareto/schemas/astn_schema/resolve.d.ts

@@ -0,0 +1,192 @@
+import * as _pi from "pareto-core-interface";
+import * as i_resolved from "./data/resolved";
+import * as i_unresolved from "./data/unresolved";
+export declare namespace Text_Type_ {
+    type I = i_unresolved.Text_Type;
+    type O = i_resolved.Text_Type;
+    namespace P {
+    }
+}
+export type Text_Type_ = ($$_: Text_Type_.I, $$_lookups: null, $$_p: null) => Text_Type_.O;
+export declare namespace Globals_ {
+    type I = i_unresolved.Globals;
+    type O = i_resolved.Globals;
+    namespace P {
+    }
+}
+export type Globals_ = ($$_: Globals_.I, $$_lookups: null, $$_p: null) => Globals_.O;
+export declare namespace Group_ {
+    type I = i_unresolved.Group;
+    type O = i_resolved.Group;
+    namespace L {
+        type noncircular_sibling_types = i_resolved.Types_.D;
+    }
+    namespace L {
+        type possibly_circular_dependent_sibling_types = i_resolved.Types_.D;
+    }
+    namespace P {
+        namespace globals {
+            type O = i_resolved.Globals_;
+        }
+        type globals = _pi.Optional_Value<globals.O>;
+        namespace imports {
+            type O = i_resolved.Imports_;
+        }
+        type imports = _pi.Optional_Value<imports.O>;
+    }
+}
+export type Group_ = ($$_: Group_.I, $$_lookups: {
+    readonly 'noncircular sibling types': _pi.Acyclic_Lookup<Group_.L.noncircular_sibling_types>;
+    readonly 'possibly circular dependent sibling types': _pi.Cyclic_Lookup<Group_.L.possibly_circular_dependent_sibling_types>;
+}, $$_p: {
+    readonly 'globals': Group_.P.globals;
+    readonly 'imports': Group_.P.imports;
+}) => Group_.O;
+export declare namespace Dictionary_ {
+    type I = i_unresolved.Dictionary;
+    type O = i_resolved.Dictionary;
+    namespace L {
+        type noncircular_sibling_types = i_resolved.Types_.D;
+    }
+    namespace L {
+        type possibly_circular_dependent_sibling_types = i_resolved.Types_.D;
+    }
+    namespace P {
+        namespace globals {
+            type O = i_resolved.Globals_;
+        }
+        type globals = _pi.Optional_Value<globals.O>;
+        namespace imports {
+            type O = i_resolved.Imports_;
+        }
+        type imports = _pi.Optional_Value<imports.O>;
+    }
+}
+export type Dictionary_ = ($$_: Dictionary_.I, $$_lookups: {
+    readonly 'noncircular sibling types': _pi.Acyclic_Lookup<Dictionary_.L.noncircular_sibling_types>;
+    readonly 'possibly circular dependent sibling types': _pi.Cyclic_Lookup<Dictionary_.L.possibly_circular_dependent_sibling_types>;
+}, $$_p: {
+    readonly 'globals': Dictionary_.P.globals;
+    readonly 'imports': Dictionary_.P.imports;
+}) => Dictionary_.O;
+export declare namespace Type_Node_ {
+    type I = i_unresolved.Type_Node;
+    type O = i_resolved.Type_Node;
+    namespace L {
+        type noncircular_sibling_types = i_resolved.Types_.D;
+    }
+    namespace L {
+        type possibly_circular_dependent_sibling_types = i_resolved.Types_.D;
+    }
+    namespace P {
+        namespace globals {
+            type O = i_resolved.Globals_;
+        }
+        type globals = _pi.Optional_Value<globals.O>;
+        namespace imports {
+            type O = i_resolved.Imports_;
+        }
+        type imports = _pi.Optional_Value<imports.O>;
+    }
+}
+export type Type_Node_ = ($$_: Type_Node_.I, $$_lookups: {
+    readonly 'noncircular sibling types': _pi.Acyclic_Lookup<Type_Node_.L.noncircular_sibling_types>;
+    readonly 'possibly circular dependent sibling types': _pi.Cyclic_Lookup<Type_Node_.L.possibly_circular_dependent_sibling_types>;
+}, $$_p: {
+    readonly 'globals': Type_Node_.P.globals;
+    readonly 'imports': Type_Node_.P.imports;
+}) => Type_Node_.O;
+export declare namespace Type_ {
+    type I = i_unresolved.Type;
+    type O = i_resolved.Type;
+    namespace L {
+        type noncircular_sibling_types = i_resolved.Types_.D;
+    }
+    namespace L {
+        type possibly_circular_dependent_sibling_types = i_resolved.Types_.D;
+    }
+    namespace P {
+        namespace globals {
+            type O = i_resolved.Globals_;
+        }
+        type globals = _pi.Optional_Value<globals.O>;
+        namespace imports {
+            type O = i_resolved.Imports_;
+        }
+        type imports = _pi.Optional_Value<imports.O>;
+    }
+}
+export type Type_ = ($$_: Type_.I, $$_lookups: {
+    readonly 'noncircular sibling types': _pi.Acyclic_Lookup<Type_.L.noncircular_sibling_types>;
+    readonly 'possibly circular dependent sibling types': _pi.Cyclic_Lookup<Type_.L.possibly_circular_dependent_sibling_types>;
+}, $$_p: {
+    readonly 'globals': Type_.P.globals;
+    readonly 'imports': Type_.P.imports;
+}) => Type_.O;
+export declare namespace Schemas_ {
+    type I = i_unresolved.Schemas;
+    type O = i_resolved.Schemas;
+    namespace L {
+        type sibling_schemas = i_resolved.Schemas_.D;
+    }
+    namespace P {
+    }
+}
+export type Schemas_ = ($$_: Schemas_.I, $$_lookups: {
+    readonly 'sibling schemas': _pi.Stack_Lookup<Schemas_.L.sibling_schemas>;
+}, $$_p: null) => Schemas_.O;
+export declare namespace Schema_Tree_ {
+    type I = i_unresolved.Schema_Tree;
+    type O = i_resolved.Schema_Tree;
+    namespace L {
+        type sibling_schemas = i_resolved.Schemas_.D;
+    }
+    namespace P {
+    }
+}
+export type Schema_Tree_ = ($$_: Schema_Tree_.I, $$_lookups: {
+    readonly 'sibling schemas': _pi.Stack_Lookup<Schema_Tree_.L.sibling_schemas>;
+}, $$_p: null) => Schema_Tree_.O;
+export declare namespace Schema_ {
+    type I = i_unresolved.Schema;
+    type O = i_resolved.Schema;
+    namespace L {
+        type sibling_schemas = i_resolved.Schemas_.D;
+    }
+    namespace P {
+    }
+}
+export type Schema_ = ($$_: Schema_.I, $$_lookups: {
+    readonly 'sibling schemas': _pi.Stack_Lookup<Schema_.L.sibling_schemas>;
+}, $$_p: null) => Schema_.O;
+export declare namespace Imports_ {
+    type I = i_unresolved.Imports;
+    type O = i_resolved.Imports;
+    namespace L {
+        type sibling_schemas = i_resolved.Schemas_.D;
+    }
+    namespace P {
+    }
+}
+export type Imports_ = ($$_: Imports_.I, $$_lookups: {
+    readonly 'sibling schemas': _pi.Stack_Lookup<Imports_.L.sibling_schemas>;
+}, $$_p: null) => Imports_.O;
+export declare namespace Types_ {
+    type I = i_unresolved.Types;
+    type O = i_resolved.Types;
+    namespace P {
+        namespace globals {
+            type O = i_resolved.Globals_;
+        }
+        type globals = _pi.Optional_Value<globals.O>;
+        namespace imports {
+            type O = i_resolved.Imports_;
+        }
+        type imports = _pi.Optional_Value<imports.O>;
+    }
+}
+export type Types_ = ($$_: Types_.I, $$_lookups: null, $$_p: {
+    readonly 'globals': Types_.P.globals;
+    readonly 'imports': Types_.P.imports;
+}) => Types_.O;
+export { Text_Type_ as Text_Type, Globals_ as Globals, Group_ as Group, Dictionary_ as Dictionary, Type_Node_ as Type_Node, Type_ as Type, Schemas_ as Schemas, Schema_Tree_ as Schema_Tree, Schema_ as Schema, Imports_ as Imports, Types_ as Types, };

package/dist/interface/generated/pareto/schemas/astn_schema/resolve.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb2x2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL2FzdG5fc2NoZW1hL3Jlc29sdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/interface/generated/pareto/schemas/authoring_target/data.d.ts

@@ -0,0 +1,102 @@
+import * as _pi from "pareto-core-interface";
+export declare namespace Value_ {
+    namespace metadata {
+        namespace comments {
+            type L = string;
+        }
+        type comments = _pi.List<comments.L>;
+    }
+    type metadata = {
+        readonly 'comments': metadata.comments;
+    };
+    namespace data {
+        type missing = null;
+        namespace include {
+            type path = string;
+        }
+        type include = {
+            readonly 'path': include.path;
+        };
+        namespace concrete {
+            namespace _type {
+                namespace dictionary {
+                    namespace D {
+                        type O = Value_;
+                    }
+                    type D = _pi.Optional_Value<D.O>;
+                }
+                type dictionary = _pi.Dictionary<dictionary.D>;
+                namespace group {
+                    namespace concise {
+                        type L = Value_;
+                    }
+                    type concise = _pi.List<concise.L>;
+                    namespace verbose {
+                        namespace D {
+                            type O = Value_;
+                        }
+                        type D = _pi.Optional_Value<D.O>;
+                    }
+                    type verbose = _pi.Dictionary<verbose.D>;
+                }
+                type group = readonly ['concise', group.concise] | readonly ['verbose', group.verbose];
+                namespace list {
+                    type L = Value_;
+                }
+                type list = _pi.List<list.L>;
+                type nothing = null;
+                namespace optional {
+                    type not_set = null;
+                    type _set = Value_;
+                }
+                type optional = readonly ['not set', optional.not_set] | readonly ['set', optional._set];
+                namespace state_group {
+                    type missing_data = null;
+                    namespace _set {
+                        type state = string;
+                        type value = Value_;
+                    }
+                    type _set = {
+                        readonly 'state': _set.state;
+                        readonly 'value': _set.value;
+                    };
+                }
+                type state_group = readonly ['missing data', state_group.missing_data] | readonly ['set', state_group._set];
+                namespace text {
+                    type value = string;
+                    namespace delimiter {
+                        type none = null;
+                        type quote = null;
+                        type backtick = null;
+                    }
+                    type delimiter = readonly ['none', delimiter.none] | readonly ['quote', delimiter.quote] | readonly ['backtick', delimiter.backtick];
+                }
+                type text = {
+                    readonly 'value': text.value;
+                    readonly 'delimiter': text.delimiter;
+                };
+            }
+            type _type = readonly ['dictionary', _type.dictionary] | readonly ['group', _type.group] | readonly ['list', _type.list] | readonly ['nothing', _type.nothing] | readonly ['optional', _type.optional] | readonly ['state group', _type.state_group] | readonly ['text', _type.text];
+        }
+        type concrete = {
+            readonly 'type': concrete._type;
+        };
+    }
+    type data = readonly ['missing', data.missing] | readonly ['include', data.include] | readonly ['concrete', data.concrete];
+}
+export type Value_ = {
+    readonly 'metadata': Value_.metadata;
+    readonly 'data': Value_.data;
+};
+export declare namespace Document_ {
+    namespace header {
+        type O = Value_;
+    }
+    type header = _pi.Optional_Value<header.O>;
+    type content = Value_;
+}
+export type Document_ = {
+    readonly 'header': Document_.header;
+    readonly 'content': Document_.content;
+};
+export { Value_ as Value, Document_ as Document, };

package/dist/interface/generated/pareto/schemas/authoring_target/data.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL2F1dGhvcmluZ190YXJnZXQvZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/interface/generated/pareto/schemas/authoring_target/migrate_boilerplate.d.ts

@@ -1,5 +1,5 @@
-import * as i_out from "./data_types/target";
-import * as i_in from "./data_types/source";
+import * as i_out from "./data";
+import * as i_in from "./data";
 export declare namespace Value_ {
     type I = i_in.Value;
     type O = i_out.Value;

package/dist/interface/generated/pareto/schemas/deserialize_parse_tree/data.d.ts

@@ -0,0 +1,71 @@
+import * as _pi from "pareto-core-interface";
+import * as i__imports_token from "../token/data";
+export declare namespace Lexer_Error_ {
+    namespace _type {
+        type unexpected_control_character = number;
+        type missing_character_after_escape = null;
+        type unexpected_end_of_line_in_delimited_text = null;
+        type unexpected_character = number;
+        type unterminated_text = null;
+        type unterminated_block_comment = null;
+        type unterminated_unicode_escape_sequence = null;
+        type invalid_unicode_escape_sequence = null;
+        type unknown_escape_character = null;
+        type unexpected_end_of_input = null;
+        type dangling_slash = null;
+    }
+    type _type = readonly ['unexpected control character', _type.unexpected_control_character] | readonly ['missing character after escape', _type.missing_character_after_escape] | readonly ['unexpected end of line in delimited text', _type.unexpected_end_of_line_in_delimited_text] | readonly ['unexpected character', _type.unexpected_character] | readonly ['unterminated text', _type.unterminated_text] | readonly ['unterminated block comment', _type.unterminated_block_comment] | readonly ['unterminated unicode escape sequence', _type.unterminated_unicode_escape_sequence] | readonly ['invalid unicode escape sequence', _type.invalid_unicode_escape_sequence] | readonly ['unknown escape character', _type.unknown_escape_character] | readonly ['unexpected end of input', _type.unexpected_end_of_input] | readonly ['dangling slash', _type.dangling_slash];
+    namespace range {
+        type O = i__imports_token.Range;
+    }
+    type range = _pi.Optional_Value<range.O>;
+}
+export type Lexer_Error_ = {
+    readonly 'type': Lexer_Error_._type;
+    readonly 'range': Lexer_Error_.range;
+};
+export declare namespace Expected_ {
+    type a_text_value = null;
+    type any_value = null;
+    type $ex_ = null;
+    type $gt_ = null;
+    type $cc_ = null;
+    type $at_ = null;
+    type $cm_ = null;
+    type $cl_ = null;
+    type $pc_ = null;
+    type $bc_ = null;
+    type $ha_ = null;
+}
+export type Expected_ = readonly ['a text value', Expected_.a_text_value] | readonly ['any value', Expected_.any_value] | readonly ['!', Expected_.$ex_] | readonly ['>', Expected_.$gt_] | readonly ['}', Expected_.$cc_] | readonly ['@', Expected_.$at_] | readonly [',', Expected_.$cm_] | readonly [':', Expected_.$cl_] | readonly [')', Expected_.$pc_] | readonly [']', Expected_.$bc_] | readonly ['#', Expected_.$ha_];
+export declare namespace Parser_Error_ {
+    namespace expected {
+        type L = Expected_;
+    }
+    type expected = _pi.List<expected.L>;
+    namespace cause {
+        type missing_token = null;
+        namespace unexpected_token {
+            type found = i__imports_token.Annotated_Token;
+        }
+        type unexpected_token = {
+            readonly 'found': unexpected_token.found;
+        };
+    }
+    type cause = readonly ['missing token', cause.missing_token] | readonly ['unexpected token', cause.unexpected_token];
+}
+export type Parser_Error_ = {
+    readonly 'expected': Parser_Error_.expected;
+    readonly 'cause': Parser_Error_.cause;
+};
+export declare namespace Error_ {
+    namespace _type {
+        type lexer = Lexer_Error_;
+        type parser = Parser_Error_;
+    }
+    type _type = readonly ['lexer', _type.lexer] | readonly ['parser', _type.parser];
+}
+export type Error_ = {
+    readonly 'type': Error_._type;
+};
+export { Lexer_Error_ as Lexer_Error, Expected_ as Expected, Parser_Error_ as Parser_Error, Error_ as Error, };

package/dist/interface/generated/pareto/schemas/deserialize_parse_tree/data.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL2Rlc2VyaWFsaXplX3BhcnNlX3RyZWUvZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/interface/generated/pareto/schemas/deserialize_parse_tree/data_types/resolve.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/interface/generated/pareto/schemas/deserialize_parse_tree/data_types/resolve.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb2x2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL2Rlc2VyaWFsaXplX3BhcnNlX3RyZWUvZGF0YV90eXBlcy9yZXNvbHZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==