pareto-liana 0.0.0

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/module/data/resolved.d.ts

@@ -0,0 +1,33 @@
+import * as _pi from "pareto-core-interface";
+import * as i__imports_schema from "../../schema/data/resolved";
+export declare namespace Operations_ {
+    namespace D {
+        namespace operation {
+            type type_parameters = i__imports_schema.Type_Parameters;
+            type context = i__imports_schema.Type_Node;
+            namespace parameters {
+                type D = i__imports_schema.Type_Node;
+            }
+            type parameters = _pi.Dictionary<parameters.D>;
+            type result = i__imports_schema.Type_Node;
+        }
+        type operation = {
+            readonly 'type parameters': operation.type_parameters;
+            readonly 'context': operation.context;
+            readonly 'parameters': operation.parameters;
+            readonly 'result': operation.result;
+        };
+        type _set = Operations_;
+    }
+    type D = readonly ['operation', D.operation] | readonly ['set', D._set];
+}
+export type Operations_ = _pi.Dictionary<Operations_.D>;
+export declare namespace Module_ {
+    type schema_tree = i__imports_schema.Schema_Tree;
+    type operations = Operations_;
+}
+export type Module_ = {
+    readonly 'schema tree': Module_.schema_tree;
+    readonly 'operations': Module_.operations;
+};
+export { Operations_ as Operations, Module_ as Module, };

package/dist/interface/generated/pareto/schemas/module/data/resolved.js

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

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

@@ -0,0 +1,69 @@
+import * as _pi from "pareto-core-interface";
+import * as i__location from "../../../core/location";
+import * as i__imports_schema from "../../schema/data/unresolved";
+export declare namespace Operations_ {
+    type location = i__location.Location;
+    namespace dictionary {
+        namespace D {
+            type location = i__location.Location;
+            namespace entry {
+                type location = i__location.Location;
+                namespace state_group {
+                    namespace operation {
+                        type type_parameters = i__imports_schema.Type_Parameters;
+                        type context = i__imports_schema.Type_Node;
+                        namespace parameters {
+                            type location = i__location.Location;
+                            namespace dictionary {
+                                namespace D {
+                                    type location = i__location.Location;
+                                    type entry = i__imports_schema.Type_Node;
+                                }
+                                type D = {
+                                    readonly 'location': D.location;
+                                    readonly 'entry': D.entry;
+                                };
+                            }
+                            type dictionary = _pi.Dictionary<dictionary.D>;
+                        }
+                        type parameters = {
+                            readonly 'location': parameters.location;
+                            readonly 'dictionary': parameters.dictionary;
+                        };
+                        type result = i__imports_schema.Type_Node;
+                    }
+                    type operation = {
+                        readonly 'type parameters': operation.type_parameters;
+                        readonly 'context': operation.context;
+                        readonly 'parameters': operation.parameters;
+                        readonly 'result': operation.result;
+                    };
+                    type _set = Operations_;
+                }
+                type state_group = readonly ['operation', state_group.operation] | readonly ['set', state_group._set];
+            }
+            type entry = {
+                readonly 'location': entry.location;
+                readonly 'state group': entry.state_group;
+            };
+        }
+        type D = {
+            readonly 'location': D.location;
+            readonly 'entry': D.entry;
+        };
+    }
+    type dictionary = _pi.Dictionary<dictionary.D>;
+}
+export type Operations_ = {
+    readonly 'location': Operations_.location;
+    readonly 'dictionary': Operations_.dictionary;
+};
+export declare namespace Module_ {
+    type schema_tree = i__imports_schema.Schema_Tree;
+    type operations = Operations_;
+}
+export type Module_ = {
+    readonly 'schema tree': Module_.schema_tree;
+    readonly 'operations': Module_.operations;
+};
+export { Operations_ as Operations, Module_ as Module, };

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

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

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

@@ -0,0 +1,15 @@
+import * as _pi from "pareto-core-interface";
+import * as _i_resolved from "../data/resolved";
+import * as _i_unresolved from "../data/unresolved";
+export type Module = ($$_: _i_unresolved.Module, abort: _pi.Abort<null>, $$_p: {
+    readonly 'parameters': {
+        readonly 'values': null;
+        readonly 'lookups': null;
+    };
+}) => _i_resolved.Module;
+export type Operations = ($$_: _i_unresolved.Operations, abort: _pi.Abort<null>, $$_p: {
+    readonly 'parameters': {
+        readonly 'values': null;
+        readonly 'lookups': null;
+    };
+}) => _i_resolved.Operations;

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

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

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

@@ -0,0 +1,17 @@
+import * as i_out from "./data/unresolved";
+import * as i_in from "./data/resolved";
+export declare namespace Operations_ {
+    type I = i_in.Operations;
+    type O = i_out.Operations;
+    namespace P {
+    }
+}
+export type Operations_ = ($$_: Operations_.I) => Operations_.O;
+export declare namespace Module_ {
+    type I = i_in.Module;
+    type O = i_out.Module;
+    namespace P {
+    }
+}
+export type Module_ = ($$_: Module_.I) => Module_.O;
+export { Operations_ as Operations, Module_ as Module, };

package/dist/interface/generated/pareto/schemas/module/migrate_boilerplate.js

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

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

@@ -0,0 +1,17 @@
+import * as i_resolved from "./data/resolved";
+import * as i_unresolved from "./data/unresolved";
+export declare namespace Module_ {
+    type I = i_unresolved.Module;
+    type O = i_resolved.Module;
+    namespace P {
+    }
+}
+export type Module_ = ($$_: Module_.I, $$_lookups: null, $$_p: null) => Module_.O;
+export declare namespace Operations_ {
+    type I = i_unresolved.Operations;
+    type O = i_resolved.Operations;
+    namespace P {
+    }
+}
+export type Operations_ = ($$_: Operations_.I, $$_lookups: null, $$_p: null) => Operations_.O;
+export { Module_ as Module, Operations_ as Operations, };

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

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

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

@@ -0,0 +1,182 @@
+import * as _pi from "pareto-core-interface";
+import * as i__imports_token from "../token/data";
+export declare namespace Structural_Token_ {
+    type trailing_trivia = i__imports_token.Trivia;
+    type range = i__imports_token.Range;
+}
+export type Structural_Token_ = {
+    readonly 'trailing trivia': Structural_Token_.trailing_trivia;
+    readonly 'range': Structural_Token_.range;
+};
+export declare namespace Text_ {
+    type trailing_trivia = i__imports_token.Trivia;
+    type range = i__imports_token.Range;
+    type value = string;
+    type _type = i__imports_token.Text_Type;
+}
+export type Text_ = {
+    readonly 'trailing trivia': Text_.trailing_trivia;
+    readonly 'range': Text_.range;
+    readonly 'value': Text_.value;
+    readonly 'type': Text_._type;
+};
+export declare namespace Key_Value_Pairs_ {
+    namespace L {
+        type key = Text_;
+        namespace value {
+            namespace O {
+                type $cl_ = Structural_Token_;
+                type value = Value_;
+            }
+            type O = {
+                readonly ':': O.$cl_;
+                readonly 'value': O.value;
+            };
+        }
+        type value = _pi.Optional_Value<value.O>;
+    }
+    type L = {
+        readonly 'key': L.key;
+        readonly 'value': L.value;
+    };
+}
+export type Key_Value_Pairs_ = _pi.List<Key_Value_Pairs_.L>;
+export declare namespace Elements_ {
+    namespace L {
+        type value = Value_;
+    }
+    type L = {
+        readonly 'value': L.value;
+    };
+}
+export type Elements_ = _pi.List<Elements_.L>;
+export declare namespace Value_ {
+    namespace _type {
+        namespace concrete {
+            namespace dictionary {
+                type $co_ = Structural_Token_;
+                type entries = Key_Value_Pairs_;
+                type $cc_ = Structural_Token_;
+            }
+            type dictionary = {
+                readonly '{': dictionary.$co_;
+                readonly 'entries': dictionary.entries;
+                readonly '}': dictionary.$cc_;
+            };
+            namespace group {
+                namespace concise {
+                    type $st_ = Structural_Token_;
+                    type elements = Elements_;
+                    type $gt_ = Structural_Token_;
+                }
+                type concise = {
+                    readonly '<': concise.$st_;
+                    readonly 'elements': concise.elements;
+                    readonly '>': concise.$gt_;
+                };
+                namespace verbose {
+                    type $po_ = Structural_Token_;
+                    type entries = Key_Value_Pairs_;
+                    type $pc_ = Structural_Token_;
+                }
+                type verbose = {
+                    readonly '(': verbose.$po_;
+                    readonly 'entries': verbose.entries;
+                    readonly ')': verbose.$pc_;
+                };
+            }
+            type group = readonly ['concise', group.concise] | readonly ['verbose', group.verbose];
+            namespace list {
+                type $bo_ = Structural_Token_;
+                type elements = Elements_;
+                type $bc_ = Structural_Token_;
+            }
+            type list = {
+                readonly '[': list.$bo_;
+                readonly 'elements': list.elements;
+                readonly ']': list.$bc_;
+            };
+            namespace nothing {
+                type $ti_ = Structural_Token_;
+            }
+            type nothing = {
+                readonly '~': nothing.$ti_;
+            };
+            namespace optional {
+                namespace _set {
+                    type $sr_ = Structural_Token_;
+                    type value = Value_;
+                }
+                type _set = {
+                    readonly '*': _set.$sr_;
+                    readonly 'value': _set.value;
+                };
+            }
+            type optional = readonly ['set', optional._set];
+            namespace state_group {
+                type $vb_ = Structural_Token_;
+                namespace status {
+                    namespace missing_data {
+                        type $ha_ = Structural_Token_;
+                    }
+                    type missing_data = {
+                        readonly '#': missing_data.$ha_;
+                    };
+                    namespace _set {
+                        type state = Text_;
+                        type value = Value_;
+                    }
+                    type _set = {
+                        readonly 'state': _set.state;
+                        readonly 'value': _set.value;
+                    };
+                }
+                type status = readonly ['missing data', status.missing_data] | readonly ['set', status._set];
+            }
+            type state_group = {
+                readonly '|': state_group.$vb_;
+                readonly 'status': state_group.status;
+            };
+            type text = Text_;
+        }
+        type concrete = readonly ['dictionary', concrete.dictionary] | readonly ['group', concrete.group] | readonly ['list', concrete.list] | readonly ['nothing', concrete.nothing] | readonly ['optional', concrete.optional] | readonly ['state group', concrete.state_group] | readonly ['text', concrete.text];
+        namespace include {
+            type $at_ = Structural_Token_;
+            type path = Text_;
+        }
+        type include = {
+            readonly '@': include.$at_;
+            readonly 'path': include.path;
+        };
+        namespace missing_data {
+            type $ha_ = Structural_Token_;
+        }
+        type missing_data = {
+            readonly '#': missing_data.$ha_;
+        };
+    }
+    type _type = readonly ['concrete', _type.concrete] | readonly ['include', _type.include] | readonly ['missing data', _type.missing_data];
+}
+export type Value_ = {
+    readonly 'type': Value_._type;
+};
+export type Content_ = Value_;
+export declare namespace Document_ {
+    namespace header {
+        namespace O {
+            type $ex_ = Structural_Token_;
+            type value = Value_;
+        }
+        type O = {
+            readonly '!': O.$ex_;
+            readonly 'value': O.value;
+        };
+    }
+    type header = _pi.Optional_Value<header.O>;
+    type content = Content_;
+}
+export type Document_ = {
+    readonly 'header': Document_.header;
+    readonly 'content': Document_.content;
+};
+export { Structural_Token_ as Structural_Token, Text_ as Text, Key_Value_Pairs_ as Key_Value_Pairs, Elements_ as Elements, Value_ as Value, Content_ as Content, Document_ as Document, };

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

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

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

@@ -0,0 +1,52 @@
+import * as i_out from "./data";
+import * as i_in from "./data";
+export declare namespace Structural_Token_ {
+    type I = i_in.Structural_Token;
+    type O = i_out.Structural_Token;
+    namespace P {
+    }
+}
+export type Structural_Token_ = ($$_: Structural_Token_.I) => Structural_Token_.O;
+export declare namespace Text_ {
+    type I = i_in.Text;
+    type O = i_out.Text;
+    namespace P {
+    }
+}
+export type Text_ = ($$_: Text_.I) => Text_.O;
+export declare namespace Key_Value_Pairs_ {
+    type I = i_in.Key_Value_Pairs;
+    type O = i_out.Key_Value_Pairs;
+    namespace P {
+    }
+}
+export type Key_Value_Pairs_ = ($$_: Key_Value_Pairs_.I) => Key_Value_Pairs_.O;
+export declare namespace Elements_ {
+    type I = i_in.Elements;
+    type O = i_out.Elements;
+    namespace P {
+    }
+}
+export type Elements_ = ($$_: Elements_.I) => Elements_.O;
+export declare namespace Value_ {
+    type I = i_in.Value;
+    type O = i_out.Value;
+    namespace P {
+    }
+}
+export type Value_ = ($$_: Value_.I) => Value_.O;
+export declare namespace Content_ {
+    type I = i_in.Content;
+    type O = i_out.Content;
+    namespace P {
+    }
+}
+export type Content_ = ($$_: Content_.I) => Content_.O;
+export declare namespace Document_ {
+    type I = i_in.Document;
+    type O = i_out.Document;
+    namespace P {
+    }
+}
+export type Document_ = ($$_: Document_.I) => Document_.O;
+export { Structural_Token_ as Structural_Token, Text_ as Text, Key_Value_Pairs_ as Key_Value_Pairs, Elements_ as Elements, Value_ as Value, Content_ as Content, Document_ as Document, };

package/dist/interface/generated/pareto/schemas/parse_tree/migrate_boilerplate.js

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