pareto-liana 0.0.1 → 0.0.3

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

@@ -1,270 +0,0 @@
-import * as _pi from "pareto-core/dist/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/migrate_boilerplate.d.ts

@@ -1,80 +0,0 @@
-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/resolve.d.ts

@@ -1,192 +0,0 @@
-import * as _pi from "pareto-core/dist/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/module/data/resolved.d.ts

@@ -1,33 +0,0 @@
-import * as _pi from "pareto-core/dist/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/unresolved.d.ts

@@ -1,69 +0,0 @@
-import * as _pi from "pareto-core/dist/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/migrate_boilerplate.d.ts

@@ -1,17 +0,0 @@
-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/resolve.d.ts

@@ -1,19 +0,0 @@
-import * as _pi from "pareto-core/dist/interface";
-import * as i_resolved from "./data/resolved";
-import * as i_unresolved from "./data/unresolved";
-import * as gen from "../../core/resolve";
-export declare namespace Module_ {
-    type I = i_unresolved.Module;
-    type O = i_resolved.Module;
-    namespace P {
-    }
-}
-export type Module_ = ($$_: Module_.I, abort: _pi.Abort<gen.Error>, $$_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, abort: _pi.Abort<gen.Error>, $$_lookups: null, $$_p: null) => Operations_.O;
-export { Module_ as Module, Operations_ as Operations, };