astn 0.113.31 → 0.113.33

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

@@ -1,181 +0,0 @@
-import * as _pi from 'pareto-core-interface';
-export type _T_Derived_Reference<M_Source, T_Type> = null;
-export type _T_Dictionary<M_Source, T_D> = {
-    readonly 'dictionary': _pi.Dictionary<{
-        readonly 'entry': T_D;
-        readonly 'location': M_Source;
-    }>;
-    readonly 'location': M_Source;
-};
-export type _T_List<M_Source, T_L> = {
-    readonly 'list': _pi.List<{
-        readonly 'element': T_L;
-        readonly 'location': M_Source;
-    }>;
-    readonly 'location': M_Source;
-};
-export type _T_Ordered_Dictionary<M_Source, T_D> = {
-    readonly 'dictionary': _pi.Dictionary<{
-        readonly 'entry': T_D;
-        readonly 'location': M_Source;
-    }>;
-    readonly 'location': M_Source;
-};
-export type _T_Reference_To_Circular_Dependent_Sibling<M_Source, T_Dictionary_Entry> = {
-    readonly 'key': string;
-    readonly 'location': M_Source;
-};
-export type _T_Reference_To_Normal_Dictionary_Entry<M_Source, T_Dictionary_Entry> = {
-    readonly 'key': string;
-    readonly 'location': M_Source;
-};
-export type _T_Reference_To_Stacked_Dictionary_Entry<M_Source, T_Dictionary_Entry> = {
-    readonly 'key': string;
-    readonly 'location': M_Source;
-};
-export type _T_State_Group<M_Source, T_SG> = {
-    readonly 'location': M_Source;
-    readonly 'state group': T_SG;
-};
-export type Derived_Reference<M_Source, T_Type> = _T_Derived_Reference<M_Source, T_Type>;
-export type Dictionary<M_Source, T_D> = _T_Dictionary<M_Source, T_D>;
-export type List<M_Source, T_L> = _T_List<M_Source, T_L>;
-export type Ordered_Dictionary<M_Source, T_D> = _T_Ordered_Dictionary<M_Source, T_D>;
-export type Reference_To_Circular_Dependent_Sibling<M_Source, T_Dictionary_Entry> = _T_Reference_To_Circular_Dependent_Sibling<M_Source, T_Dictionary_Entry>;
-export type Reference_To_Normal_Dictionary_Entry<M_Source, T_Dictionary_Entry> = _T_Reference_To_Normal_Dictionary_Entry<M_Source, T_Dictionary_Entry>;
-export type Reference_To_Stacked_Dictionary_Entry<M_Source, T_Dictionary_Entry> = _T_Reference_To_Stacked_Dictionary_Entry<M_Source, T_Dictionary_Entry>;
-export type State_Group<M_Source, T_SG> = _T_State_Group<M_Source, T_SG>;
-export declare namespace _T_Dictionary {
-    namespace dictionary {
-        namespace D {
-            type entry<M_Source, T_D> = T_D;
-            type location<M_Source, T_D> = M_Source;
-        }
-        type D<M_Source, T_D> = {
-            readonly 'entry': T_D;
-            readonly 'location': M_Source;
-        };
-    }
-    type dictionary<M_Source, T_D> = _pi.Dictionary<{
-        readonly 'entry': T_D;
-        readonly 'location': M_Source;
-    }>;
-    type location<M_Source, T_D> = M_Source;
-}
-export declare namespace _T_List {
-    namespace list {
-        namespace L {
-            type element<M_Source, T_L> = T_L;
-            type location<M_Source, T_L> = M_Source;
-        }
-        type L<M_Source, T_L> = {
-            readonly 'element': T_L;
-            readonly 'location': M_Source;
-        };
-    }
-    type list<M_Source, T_L> = _pi.List<{
-        readonly 'element': T_L;
-        readonly 'location': M_Source;
-    }>;
-    type location<M_Source, T_L> = M_Source;
-}
-export declare namespace _T_Ordered_Dictionary {
-    namespace dictionary {
-        namespace D {
-            type entry<M_Source, T_D> = T_D;
-            type location<M_Source, T_D> = M_Source;
-        }
-        type D<M_Source, T_D> = {
-            readonly 'entry': T_D;
-            readonly 'location': M_Source;
-        };
-    }
-    type dictionary<M_Source, T_D> = _pi.Dictionary<{
-        readonly 'entry': T_D;
-        readonly 'location': M_Source;
-    }>;
-    type location<M_Source, T_D> = M_Source;
-}
-export declare namespace _T_Reference_To_Circular_Dependent_Sibling {
-    type key<M_Source, T_Dictionary_Entry> = string;
-    type location<M_Source, T_Dictionary_Entry> = M_Source;
-}
-export declare namespace _T_Reference_To_Normal_Dictionary_Entry {
-    type key<M_Source, T_Dictionary_Entry> = string;
-    type location<M_Source, T_Dictionary_Entry> = M_Source;
-}
-export declare namespace _T_Reference_To_Stacked_Dictionary_Entry {
-    type key<M_Source, T_Dictionary_Entry> = string;
-    type location<M_Source, T_Dictionary_Entry> = M_Source;
-}
-export declare namespace _T_State_Group {
-    type location<M_Source, T_SG> = M_Source;
-    type state_group<M_Source, T_SG> = T_SG;
-}
-export declare namespace Dictionary {
-    namespace dictionary {
-        namespace D {
-            type entry<M_Source, T_D> = T_D;
-            type location<M_Source, T_D> = M_Source;
-        }
-        type D<M_Source, T_D> = {
-            readonly 'entry': T_D;
-            readonly 'location': M_Source;
-        };
-    }
-    type dictionary<M_Source, T_D> = _pi.Dictionary<{
-        readonly 'entry': T_D;
-        readonly 'location': M_Source;
-    }>;
-    type location<M_Source, T_D> = M_Source;
-}
-export declare namespace List {
-    namespace list {
-        namespace L {
-            type element<M_Source, T_L> = T_L;
-            type location<M_Source, T_L> = M_Source;
-        }
-        type L<M_Source, T_L> = {
-            readonly 'element': T_L;
-            readonly 'location': M_Source;
-        };
-    }
-    type list<M_Source, T_L> = _pi.List<{
-        readonly 'element': T_L;
-        readonly 'location': M_Source;
-    }>;
-    type location<M_Source, T_L> = M_Source;
-}
-export declare namespace Ordered_Dictionary {
-    namespace dictionary {
-        namespace D {
-            type entry<M_Source, T_D> = T_D;
-            type location<M_Source, T_D> = M_Source;
-        }
-        type D<M_Source, T_D> = {
-            readonly 'entry': T_D;
-            readonly 'location': M_Source;
-        };
-    }
-    type dictionary<M_Source, T_D> = _pi.Dictionary<{
-        readonly 'entry': T_D;
-        readonly 'location': M_Source;
-    }>;
-    type location<M_Source, T_D> = M_Source;
-}
-export declare namespace Reference_To_Circular_Dependent_Sibling {
-    type key<M_Source, T_Dictionary_Entry> = string;
-    type location<M_Source, T_Dictionary_Entry> = M_Source;
-}
-export declare namespace Reference_To_Normal_Dictionary_Entry {
-    type key<M_Source, T_Dictionary_Entry> = string;
-    type location<M_Source, T_Dictionary_Entry> = M_Source;
-}
-export declare namespace Reference_To_Stacked_Dictionary_Entry {
-    type key<M_Source, T_Dictionary_Entry> = string;
-    type location<M_Source, T_Dictionary_Entry> = M_Source;
-}
-export declare namespace State_Group {
-    type location<M_Source, T_SG> = M_Source;
-    type state_group<M_Source, T_SG> = T_SG;
-}

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

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

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

@@ -1,192 +0,0 @@
-import * as _pi from "pareto-core-interface";
-import * as i_resolved from "./source";
-import * as i_unresolved from "./target";
-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/data_types/resolve.js

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

package/dist/interface/generated/pareto/schemas/astn_schema/data_types/source.d.ts

@@ -1,150 +0,0 @@
-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_types/source.js

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