astn 0.113.27 → 0.113.28

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

@@ -1,446 +1,150 @@
-import * as _i_core from "../../../core/resolved";
-export type _T_Schemas = _i_core._T_Ordered_Dictionary<null, _T_Schema_Tree>;
-export type _T_Text_Type = {
-    readonly 'type': _i_core._T_State_Group<null, readonly ['multi line', null] | readonly ['single line', null]>;
-};
-export type _T_Globals = {
-    readonly 'text types': _i_core._T_Dictionary<null, _T_Text_Type>;
-};
-export type _T_Type = {
-    readonly 'node': _T_Type_Node;
-};
-export type _T_Types = _i_core._T_Ordered_Dictionary<null, _T_Type>;
-export type _T_Schema = {
-    readonly 'imports': _T_Imports;
-    readonly 'globals': _T_Globals;
-    readonly 'types': _T_Types;
-};
-export type _T_Schema_Tree = _i_core._T_State_Group<null, readonly ['set', _T_Schemas] | readonly ['schema', _T_Schema]>;
-export type _T_Imports = _i_core._T_Dictionary<null, {
-    readonly 'schema set child': _i_core._T_Reference_To_Stacked_Dictionary_Entry<null, _T_Schemas.D>;
-    readonly 'schema': _i_core._T_Derived_Reference<null, _T_Schema>;
-}>;
-export type _T_Dictionary = {
-    readonly 'node': _T_Type_Node;
-    readonly 'ordered': boolean;
-};
-export type _T_Group = _i_core._T_Dictionary<null, _T_Type_Node>;
-export type _T_Type_Node = _i_core._T_State_Group<null, readonly [
-    'component',
-    _i_core._T_State_Group<null, readonly [
-        'external',
-        {
-            readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
-            readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
-        }
-    ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>]>
-] | readonly ['dictionary', _T_Dictionary] | readonly ['group', _T_Group] | readonly [
-    'list',
-    {
-        readonly 'node': _T_Type_Node;
-    }
-] | readonly ['nothing', null] | readonly ['optional', _T_Type_Node] | readonly ['state group', _i_core._T_Dictionary<null, _T_Type_Node>] | readonly [
-    'text',
-    _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_Text_Type]>
-]>;
-export type Schemas = _T_Schemas;
-export type Text_Type = _T_Text_Type;
-export type Globals = _T_Globals;
-export type Type = _T_Type;
-export type Types = _T_Types;
-export type Schema = _T_Schema;
-export type Schema_Tree = _T_Schema_Tree;
-export type Imports = _T_Imports;
-export type Dictionary = _T_Dictionary;
-export type Group = _T_Group;
-export type Type_Node = _T_Type_Node;
-export declare namespace _T_Schemas {
-    namespace D {
-    }
-    type D = _T_Schema_Tree;
+import * as _pi from "pareto-core-interface";
+export declare namespace Schemas_ {
+    type D = Schema_Tree_;
 }
-export declare namespace _T_Text_Type {
+export type Schemas_ = _pi.Dictionary<Schemas_.D>;
+export declare namespace Text_Type_ {
     namespace _type {
-        namespace SG {
-            type multi_line = null;
-            type single_line = null;
-        }
-        type SG = readonly ['multi line', null] | readonly ['single line', null];
+        type multi_line = null;
+        type single_line = null;
     }
-    type _type = _i_core._T_State_Group<null, readonly ['multi line', null] | readonly ['single line', null]>;
+    type _type = readonly ['multi line', _type.multi_line] | readonly ['single line', _type.single_line];
 }
-export declare namespace _T_Globals {
+export type Text_Type_ = {
+    readonly 'type': Text_Type_._type;
+};
+export declare namespace Globals_ {
     namespace text_types {
-        namespace D {
-        }
-        type D = _T_Text_Type;
-    }
-    type text_types = _i_core._T_Dictionary<null, _T_Text_Type>;
-}
-export declare namespace _T_Type {
-    namespace node {
-    }
-    type node = _T_Type_Node;
-}
-export declare namespace _T_Types {
-    namespace D {
+        type D = Text_Type_;
     }
-    type D = _T_Type;
+    type text_types = _pi.Dictionary<text_types.D>;
 }
-export declare namespace _T_Schema {
-    namespace imports {
-    }
-    type imports = _T_Imports;
-    namespace globals {
-    }
-    type globals = _T_Globals;
-    namespace types {
-    }
-    type types = _T_Types;
+export type Globals_ = {
+    readonly 'text types': Globals_.text_types;
+};
+export declare namespace Type_ {
+    type node = Type_Node_;
 }
-export declare namespace _T_Schema_Tree {
-    namespace SG {
-        namespace _set {
-        }
-        type _set = _T_Schemas;
-        namespace schema {
-        }
-        type schema = _T_Schema;
-    }
-    type SG = readonly ['set', _T_Schemas] | readonly ['schema', _T_Schema];
+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 declare namespace _T_Imports {
+export type Schema_Tree_ = readonly ['set', Schema_Tree_._set] | readonly ['schema', Schema_Tree_.schema];
+export declare namespace Imports_ {
     namespace D {
         namespace schema_set_child {
-            namespace Dictionary_Entry {
-            }
-            type Dictionary_Entry = _T_Schemas.D;
-        }
-        type schema_set_child = _i_core._T_Reference_To_Stacked_Dictionary_Entry<null, _T_Schemas.D>;
-        namespace schema {
-            namespace Type {
-            }
-            type Type = _T_Schema;
+            type entry = Schemas_.D;
+            type key = string;
         }
-        type schema = _i_core._T_Derived_Reference<null, _T_Schema>;
+        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': _i_core._T_Reference_To_Stacked_Dictionary_Entry<null, _T_Schemas.D>;
-        readonly 'schema': _i_core._T_Derived_Reference<null, _T_Schema>;
+        readonly 'schema set child': D.schema_set_child;
+        readonly 'schema': D.schema;
     };
 }
-export declare namespace _T_Dictionary {
-    namespace node {
-    }
-    type node = _T_Type_Node;
+export type Imports_ = _pi.Dictionary<Imports_.D>;
+export declare namespace Dictionary_ {
+    type node = Type_Node_;
     type ordered = boolean;
 }
-export declare namespace _T_Group {
-    namespace D {
-    }
-    type D = _T_Type_Node;
-}
-export declare namespace _T_Type_Node {
-    namespace SG {
-        namespace component {
-            namespace SG {
-                namespace external {
-                    namespace _import {
-                        namespace Dictionary_Entry {
-                        }
-                        type Dictionary_Entry = _T_Imports.D;
-                    }
-                    type _import = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
-                    namespace _type {
-                        namespace Dictionary_Entry {
-                        }
-                        type Dictionary_Entry = _T_Types.D;
-                    }
-                    type _type = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
-                }
-                type external = {
-                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
-                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
-                };
-                namespace internal {
-                    namespace Dictionary_Entry {
-                    }
-                    type Dictionary_Entry = _T_Types.D;
-                }
-                type internal = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
-                namespace internal_cyclic {
-                    namespace Dictionary_Entry {
-                    }
-                    type Dictionary_Entry = _T_Types.D;
-                }
-                type internal_cyclic = _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>;
-            }
-            type SG = readonly [
-                'external',
-                {
-                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
-                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
-                }
-            ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>];
-        }
-        type component = _i_core._T_State_Group<null, readonly [
-            'external',
-            {
-                readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
-                readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
-            }
-        ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>]>;
-        namespace dictionary {
-        }
-        type dictionary = _T_Dictionary;
-        namespace group {
-        }
-        type group = _T_Group;
-        namespace list {
-            namespace node {
-            }
-            type node = _T_Type_Node;
-        }
-        type list = {
-            readonly 'node': _T_Type_Node;
+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;
         };
-        type nothing = null;
-        namespace optional {
-        }
-        type optional = _T_Type_Node;
-        namespace state_group {
-            namespace D {
-            }
-            type D = _T_Type_Node;
-        }
-        type state_group = _i_core._T_Dictionary<null, _T_Type_Node>;
-        namespace text {
-            namespace SG {
-                namespace global {
-                    namespace Dictionary_Entry {
-                    }
-                    type Dictionary_Entry = _T_Globals.text_types.D;
-                }
-                type global = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>;
-                namespace local {
-                }
-                type local = _T_Text_Type;
-            }
-            type SG = readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_Text_Type];
-        }
-        type text = _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_Text_Type]>;
-    }
-    type SG = readonly [
-        'component',
-        _i_core._T_State_Group<null, readonly [
-            'external',
-            {
-                readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
-                readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
-            }
-        ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>]>
-    ] | readonly ['dictionary', _T_Dictionary] | readonly ['group', _T_Group] | readonly [
-        'list',
-        {
-            readonly 'node': _T_Type_Node;
-        }
-    ] | readonly ['nothing', null] | readonly ['optional', _T_Type_Node] | readonly ['state group', _i_core._T_Dictionary<null, _T_Type_Node>] | readonly [
-        'text',
-        _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_Text_Type]>
-    ];
-}
-export declare namespace Schemas {
-    namespace D {
-    }
-    type D = _T_Schema_Tree;
-}
-export declare namespace Text_Type {
-    namespace _type {
-        namespace SG {
-            type multi_line = null;
-            type single_line = null;
+        namespace internal {
+            type entry = Types_.D;
+            type key = string;
         }
-        type SG = readonly ['multi line', null] | readonly ['single line', null];
-    }
-    type _type = _i_core._T_State_Group<null, readonly ['multi line', null] | readonly ['single line', null]>;
-}
-export declare namespace Globals {
-    namespace text_types {
-        namespace D {
+        type internal = {
+            readonly 'entry': internal.entry;
+            readonly 'key': internal.key;
+        };
+        namespace internal_cyclic {
+            type entry = Types_.D;
+            type key = string;
         }
-        type D = _T_Text_Type;
-    }
-    type text_types = _i_core._T_Dictionary<null, _T_Text_Type>;
-}
-export declare namespace Type {
-    namespace node {
-    }
-    type node = _T_Type_Node;
-}
-export declare namespace Types {
-    namespace D {
-    }
-    type D = _T_Type;
-}
-export declare namespace Schema {
-    namespace imports {
-    }
-    type imports = _T_Imports;
-    namespace globals {
+        type internal_cyclic = {
+            readonly 'entry': internal_cyclic.entry;
+            readonly 'key': internal_cyclic.key;
+        };
     }
-    type globals = _T_Globals;
-    namespace types {
+    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 types = _T_Types;
-}
-export declare namespace Schema_Tree {
-    namespace SG {
-        namespace _set {
-        }
-        type _set = _T_Schemas;
-        namespace schema {
-        }
-        type schema = _T_Schema;
-    }
-    type SG = readonly ['set', _T_Schemas] | readonly ['schema', _T_Schema];
-}
-export declare namespace Imports {
-    namespace D {
-        namespace schema_set_child {
-            namespace Dictionary_Entry {
-            }
-            type Dictionary_Entry = _T_Schemas.D;
-        }
-        type schema_set_child = _i_core._T_Reference_To_Stacked_Dictionary_Entry<null, _T_Schemas.D>;
-        namespace schema {
-            namespace Type {
-            }
-            type Type = _T_Schema;
-        }
-        type schema = _i_core._T_Derived_Reference<null, _T_Schema>;
-    }
-    type D = {
-        readonly 'schema set child': _i_core._T_Reference_To_Stacked_Dictionary_Entry<null, _T_Schemas.D>;
-        readonly 'schema': _i_core._T_Derived_Reference<null, _T_Schema>;
+    type list = {
+        readonly 'node': list.node;
     };
-}
-export declare namespace Dictionary {
-    namespace node {
-    }
-    type node = _T_Type_Node;
-    type ordered = boolean;
-}
-export declare namespace Group {
-    namespace D {
-    }
-    type D = _T_Type_Node;
-}
-export declare namespace Type_Node {
-    namespace SG {
-        namespace component {
-            namespace SG {
-                namespace external {
-                    namespace _import {
-                        namespace Dictionary_Entry {
-                        }
-                        type Dictionary_Entry = _T_Imports.D;
-                    }
-                    type _import = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
-                    namespace _type {
-                        namespace Dictionary_Entry {
-                        }
-                        type Dictionary_Entry = _T_Types.D;
-                    }
-                    type _type = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
-                }
-                type external = {
-                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
-                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
-                };
-                namespace internal {
-                    namespace Dictionary_Entry {
-                    }
-                    type Dictionary_Entry = _T_Types.D;
-                }
-                type internal = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
-                namespace internal_cyclic {
-                    namespace Dictionary_Entry {
-                    }
-                    type Dictionary_Entry = _T_Types.D;
-                }
-                type internal_cyclic = _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>;
-            }
-            type SG = readonly [
-                'external',
-                {
-                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
-                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
-                }
-            ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>];
-        }
-        type component = _i_core._T_State_Group<null, readonly [
-            'external',
-            {
-                readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
-                readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
-            }
-        ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>]>;
-        namespace dictionary {
-        }
-        type dictionary = _T_Dictionary;
-        namespace group {
-        }
-        type group = _T_Group;
-        namespace list {
-            namespace node {
-            }
-            type node = _T_Type_Node;
-        }
-        type list = {
-            readonly 'node': _T_Type_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 nothing = null;
-        namespace optional {
-        }
-        type optional = _T_Type_Node;
-        namespace state_group {
-            namespace D {
-            }
-            type D = _T_Type_Node;
-        }
-        type state_group = _i_core._T_Dictionary<null, _T_Type_Node>;
-        namespace text {
-            namespace SG {
-                namespace global {
-                    namespace Dictionary_Entry {
-                    }
-                    type Dictionary_Entry = _T_Globals.text_types.D;
-                }
-                type global = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>;
-                namespace local {
-                }
-                type local = _T_Text_Type;
-            }
-            type SG = readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_Text_Type];
-        }
-        type text = _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_Text_Type]>;
+        type local = Text_Type_;
     }
-    type SG = readonly [
-        'component',
-        _i_core._T_State_Group<null, readonly [
-            'external',
-            {
-                readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
-                readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
-            }
-        ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>]>
-    ] | readonly ['dictionary', _T_Dictionary] | readonly ['group', _T_Group] | readonly [
-        'list',
-        {
-            readonly 'node': _T_Type_Node;
-        }
-    ] | readonly ['nothing', null] | readonly ['optional', _T_Type_Node] | readonly ['state group', _i_core._T_Dictionary<null, _T_Type_Node>] | readonly [
-        'text',
-        _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_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, };