astn 0.113.27 → 0.113.28

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

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