pareto-liana 0.0.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare const dont_import_the_root_of_this_package_but_the_specific_file_or_files_needed = 42;

package/dist/index.js

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

package/dist/interface/generated/pareto/core/location.d.ts

@@ -0,0 +1,11 @@
+export declare namespace Location_ {
+    type file = string;
+    type line = number;
+    type column = number;
+}
+export type Location_ = {
+    readonly 'file': Location_.file;
+    readonly 'line': Location_.line;
+    readonly 'column': Location_.column;
+};
+export { Location_ as Location, };

package/dist/interface/generated/pareto/core/location.js

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

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

@@ -0,0 +1,150 @@
+import * as _pi from "pareto-core-interface";
+export declare namespace Schemas_ {
+    type D = Schema_Tree_;
+}
+export type Schemas_ = _pi.Dictionary<Schemas_.D>;
+export declare namespace Text_Type_ {
+    namespace _type {
+        type multi_line = null;
+        type single_line = null;
+    }
+    type _type = readonly ['multi line', _type.multi_line] | readonly ['single line', _type.single_line];
+}
+export type Text_Type_ = {
+    readonly 'type': Text_Type_._type;
+};
+export declare namespace Globals_ {
+    namespace text_types {
+        type D = Text_Type_;
+    }
+    type text_types = _pi.Dictionary<text_types.D>;
+}
+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 D = Type_;
+}
+export type Types_ = _pi.Dictionary<Types_.D>;
+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 _set = Schemas_;
+    type schema = Schema_;
+}
+export type Schema_Tree_ = readonly ['set', Schema_Tree_._set] | readonly ['schema', Schema_Tree_.schema];
+export declare namespace Imports_ {
+    namespace D {
+        namespace schema_set_child {
+            type entry = Schemas_.D;
+            type key = string;
+        }
+        type schema_set_child = {
+            readonly 'entry': schema_set_child.entry;
+            readonly 'key': schema_set_child.key;
+        };
+        type schema = Schema_;
+    }
+    type D = {
+        readonly 'schema set child': D.schema_set_child;
+        readonly 'schema': D.schema;
+    };
+}
+export type Imports_ = _pi.Dictionary<Imports_.D>;
+export declare namespace Dictionary_ {
+    type node = Type_Node_;
+    type ordered = boolean;
+}
+export type Dictionary_ = {
+    readonly 'node': Dictionary_.node;
+    readonly 'ordered': Dictionary_.ordered;
+};
+export declare namespace Group_ {
+    type D = Type_Node_;
+}
+export type Group_ = _pi.Dictionary<Group_.D>;
+export declare namespace Type_Node_ {
+    namespace component {
+        namespace external {
+            namespace _import {
+                type entry = Imports_.D;
+                type key = string;
+            }
+            type _import = {
+                readonly 'entry': _import.entry;
+                readonly 'key': _import.key;
+            };
+            namespace _type {
+                type entry = Types_.D;
+                type key = string;
+            }
+            type _type = {
+                readonly 'entry': _type.entry;
+                readonly 'key': _type.key;
+            };
+        }
+        type external = {
+            readonly 'import': external._import;
+            readonly 'type': external._type;
+        };
+        namespace internal {
+            type entry = Types_.D;
+            type key = string;
+        }
+        type internal = {
+            readonly 'entry': internal.entry;
+            readonly 'key': internal.key;
+        };
+        namespace internal_cyclic {
+            type entry = Types_.D;
+            type key = string;
+        }
+        type internal_cyclic = {
+            readonly 'entry': internal_cyclic.entry;
+            readonly 'key': internal_cyclic.key;
+        };
+    }
+    type component = readonly ['external', component.external] | readonly ['internal', component.internal] | readonly ['internal cyclic', component.internal_cyclic];
+    type dictionary = Dictionary_;
+    type group = Group_;
+    namespace list {
+        type node = Type_Node_;
+    }
+    type list = {
+        readonly 'node': list.node;
+    };
+    type nothing = null;
+    type optional = Type_Node_;
+    namespace state_group {
+        type D = Type_Node_;
+    }
+    type state_group = _pi.Dictionary<state_group.D>;
+    namespace text {
+        namespace global {
+            type entry = Globals_.text_types.D;
+            type key = string;
+        }
+        type global = {
+            readonly 'entry': global.entry;
+            readonly 'key': global.key;
+        };
+        type local = Text_Type_;
+    }
+    type text = readonly ['global', text.global] | readonly ['local', text.local];
+}
+export type Type_Node_ = readonly ['component', Type_Node_.component] | readonly ['dictionary', Type_Node_.dictionary] | readonly ['group', Type_Node_.group] | readonly ['list', Type_Node_.list] | readonly ['nothing', Type_Node_.nothing] | readonly ['optional', Type_Node_.optional] | readonly ['state group', Type_Node_.state_group] | readonly ['text', Type_Node_.text];
+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/resolved.js

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

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

@@ -0,0 +1,80 @@
+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;
+    namespace P {
+    }
+}
+export type Schemas_ = ($$_: Schemas_.I) => Schemas_.O;
+export declare namespace Text_Type_ {
+    type I = i_in.Text_Type;
+    type O = i_out.Text_Type;
+    namespace P {
+    }
+}
+export type Text_Type_ = ($$_: Text_Type_.I) => Text_Type_.O;
+export declare namespace Globals_ {
+    type I = i_in.Globals;
+    type O = i_out.Globals;
+    namespace P {
+    }
+}
+export type Globals_ = ($$_: Globals_.I) => Globals_.O;
+export declare namespace Type_ {
+    type I = i_in.Type;
+    type O = i_out.Type;
+    namespace P {
+    }
+}
+export type Type_ = ($$_: Type_.I) => Type_.O;
+export declare namespace Types_ {
+    type I = i_in.Types;
+    type O = i_out.Types;
+    namespace P {
+    }
+}
+export type Types_ = ($$_: Types_.I) => Types_.O;
+export declare namespace Schema_ {
+    type I = i_in.Schema;
+    type O = i_out.Schema;
+    namespace P {
+    }
+}
+export type Schema_ = ($$_: Schema_.I) => Schema_.O;
+export declare namespace Schema_Tree_ {
+    type I = i_in.Schema_Tree;
+    type O = i_out.Schema_Tree;
+    namespace P {
+    }
+}
+export type Schema_Tree_ = ($$_: Schema_Tree_.I) => Schema_Tree_.O;
+export declare namespace Imports_ {
+    type I = i_in.Imports;
+    type O = i_out.Imports;
+    namespace P {
+    }
+}
+export type Imports_ = ($$_: Imports_.I) => Imports_.O;
+export declare namespace Dictionary_ {
+    type I = i_in.Dictionary;
+    type O = i_out.Dictionary;
+    namespace P {
+    }
+}
+export type Dictionary_ = ($$_: Dictionary_.I) => Dictionary_.O;
+export declare namespace Group_ {
+    type I = i_in.Group;
+    type O = i_out.Group;
+    namespace P {
+    }
+}
+export type Group_ = ($$_: Group_.I) => Group_.O;
+export declare namespace Type_Node_ {
+    type I = i_in.Type_Node;
+    type O = i_out.Type_Node;
+    namespace P {
+    }
+}
+export type Type_Node_ = ($$_: Type_Node_.I) => Type_Node_.O;
+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/migrate_boilerplate.js

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