diff --git a/plantuml/parser/integration_test/class_diagram/class_diagram_positive/class_diagram_positive.puml b/plantuml/parser/integration_test/class_diagram/class_diagram_positive/class_diagram_positive.puml
index 5b0b23a7..e65996a7 100644
--- a/plantuml/parser/integration_test/class_diagram/class_diagram_positive/class_diagram_positive.puml
+++ b/plantuml/parser/integration_test/class_diagram/class_diagram_positive/class_diagram_positive.puml
@@ -81,10 +81,10 @@ package core::geometry::advanced <<experimental>> {
 package util <<infrastructure>> {
 
     enum LogLevel {
-        -De : Debug
-        +Info : Information
-        +Warn : Warnning
-        #Err : Error
+        De : Debug
+        Info : Information
+        Warn : Warnning
+        Err : Error
     }
 
     class Logger {
diff --git a/plantuml/parser/integration_test/class_diagram/class_diagram_positive/output.json b/plantuml/parser/integration_test/class_diagram/class_diagram_positive/output.json
index 2e49260a..815beafe 100644
--- a/plantuml/parser/integration_test/class_diagram/class_diagram_positive/output.json
+++ b/plantuml/parser/integration_test/class_diagram/class_diagram_positive/output.json
@@ -1,622 +1,530 @@
-{"class_diagram_positive.puml":
-  {
-      "name": "class_positive_test",
-      "entities": [
-        {
-          "id": "core.Point",
-          "name": "Point",
-          "alias": null,
-          "parent_id": "core",
-          "entity_type": "Struct",
-          "stereotypes": [],
-          "attributes": [
-            {
-              "name": "x",
-              "data_type": "f32",
-              "visibility": "public",
-              "default_value": null,
-              "is_static": false,
-              "is_const": false,
-              "description": null
-            },
-            {
-              "name": "y",
-              "data_type": "f32",
-              "visibility": "public",
-              "default_value": null,
-              "is_static": false,
-              "is_const": false,
-              "description": null
-            }
-          ],
-          "methods": [],
-          "template_params": [],
-          "enum_literals": [],
-          "source_file": null,
-          "source_line": null
-        },
-        {
-          "id": "core.Size",
-          "name": "Size",
-          "alias": null,
-          "parent_id": "core",
-          "entity_type": "Struct",
-          "stereotypes": [],
-          "attributes": [
-            {
-              "name": "width",
-              "data_type": "f32",
-              "visibility": "public",
-              "default_value": null,
-              "is_static": false,
-              "is_const": false,
-              "description": null
-            },
-            {
-              "name": "height",
-              "data_type": "f32",
-              "visibility": "public",
-              "default_value": null,
-              "is_static": false,
-              "is_const": false,
-              "description": null
-            }
-          ],
-          "methods": [],
-          "template_params": [],
-          "enum_literals": [],
-          "source_file": null,
-          "source_line": null
-        },
-        {
-          "id": "core.Color",
-          "name": null,
-          "alias": null,
-          "parent_id": "core",
-          "entity_type": "Enum",
-          "stereotypes": [],
-          "attributes": [],
-          "methods": [],
-          "template_params": [],
-          "enum_literals": [
-            {
-              "name": "Red",
-              "visibility": "public",
-              "value": "0",
-              "description": null
-            },
-            {
-              "name": "Green",
-              "visibility": "public",
-              "value": "1",
-              "description": null
-            },
-            {
-              "name": "Blue",
-              "visibility": "public",
-              "value": "2",
-              "description": null
-            }
-          ],
-          "source_file": null,
-          "source_line": null
-        },
-        {
-          "id": "core.Shape",
-          "name": "Shape",
-          "alias": null,
-          "parent_id": "core",
-          "entity_type": "Class",
-          "stereotypes": [],
-          "attributes": [],
-          "methods": [
-            {
-              "name": "draw",
-              "return_type": null,
-              "visibility": "public",
-              "parameters": [],
-              "template_params": [],
-              "is_static": false,
-              "is_const": false,
-              "is_virtual": false,
-              "is_abstract": false,
-              "is_override": false,
-              "is_constructor": false,
-              "is_destructor": false
-            },
-            {
-              "name": "area",
-              "return_type": "f32",
-              "visibility": "public",
-              "parameters": [],
-              "template_params": [],
-              "is_static": false,
-              "is_const": false,
-              "is_virtual": false,
-              "is_abstract": false,
-              "is_override": false,
-              "is_constructor": false,
-              "is_destructor": false
-            }
-          ],
-          "template_params": [],
-          "enum_literals": [],
-          "source_file": null,
-          "source_line": null
-        },
-        {
-          "id": "core.Drawable",
-          "name": "Drawable",
-          "alias": null,
-          "parent_id": "core",
-          "entity_type": "Interface",
-          "stereotypes": [],
-          "attributes": [],
-          "methods": [
-            {
-              "name": "draw",
-              "return_type": null,
-              "visibility": "public",
-              "parameters": [],
-              "template_params": [],
-              "is_static": false,
-              "is_const": false,
-              "is_virtual": false,
-              "is_abstract": false,
-              "is_override": false,
-              "is_constructor": false,
-              "is_destructor": false
-            }
-          ],
-          "template_params": [],
-          "enum_literals": [],
-          "source_file": null,
-          "source_line": null
-        },
-        {
-          "id": "core.Canvas",
-          "name": "Canvas",
-          "alias": null,
-          "parent_id": "core",
-          "entity_type": "Class",
-          "stereotypes": [],
-          "attributes": [
-            {
-              "name": "shapes",
-              "data_type": "Shape",
-              "visibility": "private",
-              "default_value": null,
-              "is_static": false,
-              "is_const": false,
-              "description": null
-            }
-          ],
-          "methods": [
-            {
-              "name": "add_shape",
-              "return_type": null,
-              "visibility": "public",
-              "parameters": [
-                {
-                  "name": "s",
-                  "param_type": "Shape",
-                  "default_value": null,
-                  "is_reference": false,
-                  "is_const": false,
-                  "is_variadic": false
-                }
-              ],
-              "template_params": [],
-              "is_static": false,
-              "is_const": false,
-              "is_virtual": false,
-              "is_abstract": false,
-              "is_override": false,
-              "is_constructor": false,
-              "is_destructor": false
-            },
-            {
-              "name": "render",
-              "return_type": null,
-              "visibility": "public",
-              "parameters": [],
-              "template_params": [],
-              "is_static": false,
-              "is_const": false,
-              "is_virtual": false,
-              "is_abstract": false,
-              "is_override": false,
-              "is_constructor": false,
-              "is_destructor": false
-            }
-          ],
-          "template_params": [],
-          "enum_literals": [],
-          "source_file": null,
-          "source_line": null
-        },
-        {
-          "id": "core.geometry.Circle",
-          "name": "Circle",
-          "alias": null,
-          "parent_id": "core.geometry",
-          "entity_type": "Class",
-          "stereotypes": [],
-          "attributes": [
-            {
-              "name": "center",
-              "data_type": "Point",
-              "visibility": "private",
-              "default_value": null,
-              "is_static": false,
-              "is_const": false,
-              "description": null
-            },
-            {
-              "name": "radius",
-              "data_type": "f32",
-              "visibility": "private",
-              "default_value": null,
-              "is_static": false,
-              "is_const": false,
-              "description": null
-            }
-          ],
-          "methods": [
-            {
-              "name": "area",
-              "return_type": "f32",
-              "visibility": "public",
-              "parameters": [],
-              "template_params": [],
-              "is_static": false,
-              "is_const": false,
-              "is_virtual": false,
-              "is_abstract": false,
-              "is_override": false,
-              "is_constructor": false,
-              "is_destructor": false
-            }
-          ],
-          "template_params": [],
-          "enum_literals": [],
-          "source_file": null,
-          "source_line": null
-        },
-        {
-          "id": "core.geometry.Rectangle",
-          "name": "Rectangle",
-          "alias": null,
-          "parent_id": "core.geometry",
-          "entity_type": "Class",
-          "stereotypes": [],
-          "attributes": [
-            {
-              "name": "origin",
-              "data_type": "Point",
-              "visibility": "private",
-              "default_value": null,
-              "is_static": false,
-              "is_const": false,
-              "description": null
-            },
-            {
-              "name": "size",
-              "data_type": "Size",
-              "visibility": "private",
-              "default_value": null,
-              "is_static": false,
-              "is_const": false,
-              "description": null
-            }
-          ],
-          "methods": [
-            {
-              "name": "area",
-              "return_type": "f32",
-              "visibility": "public",
-              "parameters": [],
-              "template_params": [],
-              "is_static": false,
-              "is_const": false,
-              "is_virtual": false,
-              "is_abstract": false,
-              "is_override": false,
-              "is_constructor": false,
-              "is_destructor": false
-            }
-          ],
-          "template_params": [],
-          "enum_literals": [],
-          "source_file": null,
-          "source_line": null
-        },
-        {
-          "id": "core.geometry.advanced.RoundedRectangle",
-          "name": "RoundedRectangle",
-          "alias": null,
-          "parent_id": "core.geometry.advanced",
-          "entity_type": "Class",
-          "stereotypes": [],
-          "attributes": [
-            {
-              "name": "corner_radius",
-              "data_type": "f32",
-              "visibility": "private",
-              "default_value": null,
-              "is_static": false,
-              "is_const": false,
-              "description": null
-            }
-          ],
-          "methods": [],
-          "template_params": [],
-          "enum_literals": [],
-          "source_file": null,
-          "source_line": null
-        },
-        {
-          "id": "util.LogLevel",
-          "name": null,
-          "alias": null,
-          "parent_id": "util",
-          "entity_type": "Enum",
-          "stereotypes": [],
-          "attributes": [],
-          "methods": [],
-          "template_params": [],
-          "enum_literals": [
-            {
-              "name": "De",
-              "visibility": "private",
-              "value": "Debug",
-              "description": null
-            },
-            {
-              "name": "Info",
-              "visibility": "public",
-              "value": "Information",
-              "description": null
-            },
-            {
-              "name": "Warn",
-              "visibility": "public",
-              "value": "Warnning",
-              "description": null
-            },
-            {
-              "name": "Err",
-              "visibility": "protected",
-              "value": "Error",
-              "description": null
-            }
-          ],
-          "source_file": null,
-          "source_line": null
-        },
-        {
-          "id": "util.Logger",
-          "name": "Logger",
-          "alias": null,
-          "parent_id": "util",
-          "entity_type": "Class",
-          "stereotypes": [],
-          "attributes": [],
-          "methods": [
-            {
-              "name": "log",
-              "return_type": null,
-              "visibility": "public",
-              "parameters": [
-                {
-                  "name": "level",
-                  "param_type": "LogLevel",
-                  "default_value": null,
-                  "is_reference": false,
-                  "is_const": false,
-                  "is_variadic": false
-                },
-                {
-                  "name": "msg",
-                  "param_type": "String",
-                  "default_value": null,
-                  "is_reference": false,
-                  "is_const": false,
-                  "is_variadic": false
-                }
-              ],
-              "template_params": [],
-              "is_static": false,
-              "is_const": false,
-              "is_virtual": false,
-              "is_abstract": false,
-              "is_override": false,
-              "is_constructor": false,
-              "is_destructor": false
-            }
-          ],
-          "template_params": [],
-          "enum_literals": [],
-          "source_file": null,
-          "source_line": null
-        },
-        {
-          "id": "api.RestApi",
-          "name": "RestApi",
-          "alias": null,
-          "parent_id": "api",
-          "entity_type": "Class",
-          "stereotypes": [],
-          "attributes": [],
-          "methods": [
-            {
-              "name": "handle_request",
-              "return_type": null,
-              "visibility": "public",
-              "parameters": [],
-              "template_params": [],
-              "is_static": false,
-              "is_const": false,
-              "is_virtual": false,
-              "is_abstract": false,
-              "is_override": false,
-              "is_constructor": false,
-              "is_destructor": false
-            }
-          ],
-          "template_params": [],
-          "enum_literals": [],
-          "source_file": null,
-          "source_line": null
-        }
-      ],
-      "containers": [
-        {
-          "id": "core",
-          "name": "core",
-          "parent_id": null,
-          "container_type": "Namespace"
-        },
-        {
-          "id": "core.geometry",
-          "name": "core::geometry",
-          "parent_id": null,
-          "container_type": "Package"
-        },
-        {
-          "id": "core.geometry.advanced",
-          "name": "core::geometry::advanced",
-          "parent_id": null,
-          "container_type": "Package"
-        },
-        {
-          "id": "util",
-          "name": "util",
-          "parent_id": null,
-          "container_type": "Package"
-        },
-        {
-          "id": "api",
-          "name": "api",
-          "parent_id": null,
-          "container_type": "Package"
-        }
-      ],
-      "relationships": [
-        {
-          "source": "core.geometry.Circle",
-          "target": "core.Shape",
-          "relation_type": "Inheritance",
-          "label": "inherit",
-          "stereotype": null,
-          "source_multiplicity": null,
-          "target_multiplicity": null,
-          "source_role": null,
-          "target_role": null
-        },
-        {
-          "source": "core.geometry.Rectangle",
-          "target": "core.Shape",
-          "relation_type": "Inheritance",
-          "label": null,
-          "stereotype": null,
-          "source_multiplicity": null,
-          "target_multiplicity": null,
-          "source_role": null,
-          "target_role": null
-        },
-        {
-          "source": "core.geometry.advanced.RoundedRectangle",
-          "target": "core.geometry.Rectangle",
-          "relation_type": "Inheritance",
-          "label": null,
-          "stereotype": "extend",
-          "source_multiplicity": null,
-          "target_multiplicity": null,
-          "source_role": null,
-          "target_role": null
-        },
-        {
-          "source": "core.Shape",
-          "target": "core.Drawable",
-          "relation_type": "Implementation",
-          "label": null,
-          "stereotype": null,
-          "source_multiplicity": null,
-          "target_multiplicity": null,
-          "source_role": null,
-          "target_role": null
-        },
-        {
-          "source": "core.Shape",
-          "target": "core.Canvas",
-          "relation_type": "Composition",
-          "label": null,
-          "stereotype": null,
-          "source_multiplicity": null,
-          "target_multiplicity": null,
-          "source_role": null,
-          "target_role": null
-        },
-        {
-          "source": "core.Color",
-          "target": "core.geometry.Circle",
-          "relation_type": "Aggregation",
-          "label": null,
-          "stereotype": null,
-          "source_multiplicity": null,
-          "target_multiplicity": null,
-          "source_role": null,
-          "target_role": null
-        },
-        {
-          "source": "core.geometry.Rectangle",
-          "target": "core.Color",
-          "relation_type": "Association",
-          "label": null,
-          "stereotype": null,
-          "source_multiplicity": null,
-          "target_multiplicity": null,
-          "source_role": null,
-          "target_role": null
-        },
-        {
-          "source": "core.Canvas",
-          "target": "util.Logger",
-          "relation_type": "Dependency",
-          "label": null,
-          "stereotype": null,
-          "source_multiplicity": null,
-          "target_multiplicity": null,
-          "source_role": null,
-          "target_role": null
-        },
-        {
-          "source": "api.RestApi",
-          "target": "core.Canvas",
-          "relation_type": "Dependency",
-          "label": null,
-          "stereotype": "calls",
-          "source_multiplicity": null,
-          "target_multiplicity": null,
-          "source_role": null,
-          "target_role": null
-        },
-        {
-          "source": "core.geometry.Circle",
-          "target": "core.geometry.Rectangle",
-          "relation_type": "Association",
-          "label": null,
-          "stereotype": "bidirectional",
-          "source_multiplicity": null,
-          "target_multiplicity": null,
-          "source_role": null,
-          "target_role": null
-        }
-      ],
-      "source_files": [
-        "class_positive_test"
-      ],
-      "version": null
+{
+  "class_diagram_positive.puml": {
+    "name": "class_positive_test",
+    "entities": [
+      {
+        "id": "core.Point",
+        "name": "Point",
+        "enclosing_namespace_id": "core",
+        "entity_type": "Struct",
+        "type_aliases": [],
+        "methods": [],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "class_positive_test",
+        "source_line": 25,
+        "variables": [
+          {
+            "name": "x",
+            "data_type": "f32",
+            "visibility": "public",
+            "is_static": false,
+            "is_const": false
+          },
+          {
+            "name": "y",
+            "data_type": "f32",
+            "visibility": "public",
+            "is_static": false,
+            "is_const": false
+          }
+        ],
+        "relationships": []
+      },
+      {
+        "id": "core.Size",
+        "name": "Size",
+        "enclosing_namespace_id": "core",
+        "entity_type": "Struct",
+        "type_aliases": [],
+        "methods": [],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "class_positive_test",
+        "source_line": 30,
+        "variables": [
+          {
+            "name": "width",
+            "data_type": "f32",
+            "visibility": "public",
+            "is_static": false,
+            "is_const": false
+          },
+          {
+            "name": "height",
+            "data_type": "f32",
+            "visibility": "public",
+            "is_static": false,
+            "is_const": false
+          }
+        ],
+        "relationships": []
+      },
+      {
+        "id": "core.Color",
+        "name": "Color",
+        "enclosing_namespace_id": "core",
+        "entity_type": "Enum",
+        "type_aliases": [],
+        "methods": [],
+        "template_parameters": null,
+        "enum_literals": [
+          {
+            "name": "Red",
+            "value": "0"
+          },
+          {
+            "name": "Green",
+            "value": "1"
+          },
+          {
+            "name": "Blue",
+            "value": "2"
+          }
+        ],
+        "source_file": "class_positive_test",
+        "source_line": 35,
+        "variables": [],
+        "relationships": [
+          {
+            "source": "core.Color",
+            "target": "core.geometry.Circle",
+            "relation_type": "Aggregation",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          }
+        ]
+      },
+      {
+        "id": "core.Shape",
+        "name": "Shape",
+        "enclosing_namespace_id": "core",
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "draw",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [],
+            "template_parameters": null,
+            "modifiers": []
+          },
+          {
+            "name": "area",
+            "return_type": "f32",
+            "visibility": "public",
+            "parameters": [],
+            "template_parameters": null,
+            "modifiers": []
+          }
+        ],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "class_positive_test",
+        "source_line": 41,
+        "variables": [],
+        "relationships": [
+          {
+            "source": "core.Shape",
+            "target": "core.Drawable",
+            "relation_type": "Implementation",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          },
+          {
+            "source": "core.Shape",
+            "target": "core.Canvas",
+            "relation_type": "Composition",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          }
+        ]
+      },
+      {
+        "id": "core.Drawable",
+        "name": "Drawable",
+        "enclosing_namespace_id": "core",
+        "entity_type": "Interface",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "draw",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [],
+            "template_parameters": null,
+            "modifiers": []
+          }
+        ],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "class_positive_test",
+        "source_line": 46,
+        "variables": [],
+        "relationships": []
+      },
+      {
+        "id": "core.Canvas",
+        "name": "Canvas",
+        "enclosing_namespace_id": "core",
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "add_shape",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [
+              {
+                "name": "s",
+                "param_type": "Shape",
+                "is_variadic": false
+              }
+            ],
+            "template_parameters": null,
+            "modifiers": []
+          },
+          {
+            "name": "render",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [],
+            "template_parameters": null,
+            "modifiers": []
+          }
+        ],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "class_positive_test",
+        "source_line": 50,
+        "variables": [
+          {
+            "name": "shapes",
+            "data_type": "Shape",
+            "visibility": "private",
+            "is_static": false,
+            "is_const": false
+          }
+        ],
+        "relationships": [
+          {
+            "source": "core.Canvas",
+            "target": "util.Logger",
+            "relation_type": "Dependency",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          }
+        ]
+      },
+      {
+        "id": "core.geometry.Circle",
+        "name": "Circle",
+        "enclosing_namespace_id": "core.geometry",
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "area",
+            "return_type": "f32",
+            "visibility": "public",
+            "parameters": [],
+            "template_parameters": null,
+            "modifiers": []
+          }
+        ],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "class_positive_test",
+        "source_line": 59,
+        "variables": [
+          {
+            "name": "center",
+            "data_type": "Point",
+            "visibility": "private",
+            "is_static": false,
+            "is_const": false
+          },
+          {
+            "name": "radius",
+            "data_type": "f32",
+            "visibility": "private",
+            "is_static": false,
+            "is_const": false
+          }
+        ],
+        "relationships": [
+          {
+            "source": "core.geometry.Circle",
+            "target": "core.Shape",
+            "relation_type": "Inheritance",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          },
+          {
+            "source": "core.geometry.Circle",
+            "target": "core.geometry.Rectangle",
+            "relation_type": "Association",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          }
+        ]
+      },
+      {
+        "id": "core.geometry.Rectangle",
+        "name": "Rectangle",
+        "enclosing_namespace_id": "core.geometry",
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "area",
+            "return_type": "f32",
+            "visibility": "public",
+            "parameters": [],
+            "template_parameters": null,
+            "modifiers": []
+          }
+        ],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "class_positive_test",
+        "source_line": 65,
+        "variables": [
+          {
+            "name": "origin",
+            "data_type": "Point",
+            "visibility": "private",
+            "is_static": false,
+            "is_const": false
+          },
+          {
+            "name": "size",
+            "data_type": "Size",
+            "visibility": "private",
+            "is_static": false,
+            "is_const": false
+          }
+        ],
+        "relationships": [
+          {
+            "source": "core.geometry.Rectangle",
+            "target": "core.Shape",
+            "relation_type": "Inheritance",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          },
+          {
+            "source": "core.geometry.Rectangle",
+            "target": "core.Color",
+            "relation_type": "Association",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          }
+        ]
+      },
+      {
+        "id": "core.geometry.advanced.RoundedRectangle",
+        "name": "RoundedRectangle",
+        "enclosing_namespace_id": "core.geometry.advanced",
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "class_positive_test",
+        "source_line": 75,
+        "variables": [
+          {
+            "name": "corner_radius",
+            "data_type": "f32",
+            "visibility": "private",
+            "is_static": false,
+            "is_const": false
+          }
+        ],
+        "relationships": [
+          {
+            "source": "core.geometry.advanced.RoundedRectangle",
+            "target": "core.geometry.Rectangle",
+            "relation_type": "Inheritance",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          }
+        ]
+      },
+      {
+        "id": "util.LogLevel",
+        "name": "LogLevel",
+        "enclosing_namespace_id": "util",
+        "entity_type": "Enum",
+        "type_aliases": [],
+        "methods": [],
+        "template_parameters": null,
+        "enum_literals": [
+          {
+            "name": "De",
+            "value": "Debug"
+          },
+          {
+            "name": "Info",
+            "value": "Information"
+          },
+          {
+            "name": "Warn",
+            "value": "Warnning"
+          },
+          {
+            "name": "Err",
+            "value": "Error"
+          }
+        ],
+        "source_file": "class_positive_test",
+        "source_line": 83,
+        "variables": [],
+        "relationships": []
+      },
+      {
+        "id": "util.Logger",
+        "name": "Logger",
+        "enclosing_namespace_id": "util",
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "log",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [
+              {
+                "name": "level",
+                "param_type": "LogLevel",
+                "is_variadic": false
+              },
+              {
+                "name": "msg",
+                "param_type": "String",
+                "is_variadic": false
+              }
+            ],
+            "template_parameters": null,
+            "modifiers": []
+          }
+        ],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "class_positive_test",
+        "source_line": 90,
+        "variables": [],
+        "relationships": []
+      },
+      {
+        "id": "api.RestApi",
+        "name": "RestApi",
+        "enclosing_namespace_id": "api",
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "handle_request",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [],
+            "template_parameters": null,
+            "modifiers": []
+          }
+        ],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "class_positive_test",
+        "source_line": 98,
+        "variables": [],
+        "relationships": [
+          {
+            "source": "api.RestApi",
+            "target": "core.Canvas",
+            "relation_type": "Dependency",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          }
+        ]
+      }
+    ],
+    "relationships": [
+      {
+        "source": "core.geometry.Circle",
+        "target": "core.Shape",
+        "relation_type": "Inheritance",
+        "source_multiplicity": null,
+        "target_multiplicity": null
+      },
+      {
+        "source": "core.geometry.Rectangle",
+        "target": "core.Shape",
+        "relation_type": "Inheritance",
+        "source_multiplicity": null,
+        "target_multiplicity": null
+      },
+      {
+        "source": "core.geometry.advanced.RoundedRectangle",
+        "target": "core.geometry.Rectangle",
+        "relation_type": "Inheritance",
+        "source_multiplicity": null,
+        "target_multiplicity": null
+      },
+      {
+        "source": "core.Shape",
+        "target": "core.Drawable",
+        "relation_type": "Implementation",
+        "source_multiplicity": null,
+        "target_multiplicity": null
+      },
+      {
+        "source": "core.Shape",
+        "target": "core.Canvas",
+        "relation_type": "Composition",
+        "source_multiplicity": null,
+        "target_multiplicity": null
+      },
+      {
+        "source": "core.Color",
+        "target": "core.geometry.Circle",
+        "relation_type": "Aggregation",
+        "source_multiplicity": null,
+        "target_multiplicity": null
+      },
+      {
+        "source": "core.geometry.Rectangle",
+        "target": "core.Color",
+        "relation_type": "Association",
+        "source_multiplicity": null,
+        "target_multiplicity": null
+      },
+      {
+        "source": "core.Canvas",
+        "target": "util.Logger",
+        "relation_type": "Dependency",
+        "source_multiplicity": null,
+        "target_multiplicity": null
+      },
+      {
+        "source": "api.RestApi",
+        "target": "core.Canvas",
+        "relation_type": "Dependency",
+        "source_multiplicity": null,
+        "target_multiplicity": null
+      },
+      {
+        "source": "core.geometry.Circle",
+        "target": "core.geometry.Rectangle",
+        "relation_type": "Association",
+        "source_multiplicity": null,
+        "target_multiplicity": null
+      }
+    ],
+    "source_files": [
+      "class_positive_test"
+    ],
+    "version": null
   }
 }
diff --git a/plantuml/parser/integration_test/class_diagram/class_diagram_unsupported_syntax/class_diagram_unsupported_syntax.puml b/plantuml/parser/integration_test/class_diagram/class_diagram_unsupported_syntax/class_diagram_unsupported_syntax.puml
index fe50846d..bc4f10c1 100644
--- a/plantuml/parser/integration_test/class_diagram/class_diagram_unsupported_syntax/class_diagram_unsupported_syntax.puml
+++ b/plantuml/parser/integration_test/class_diagram/class_diagram_unsupported_syntax/class_diagram_unsupported_syntax.puml
@@ -47,6 +47,10 @@ package sample::newline #Lavender
 
     interface ServiceContract
 
+    abstract class myClass {
+        func() = 0
+    }
+
     interface CheckProgrammingDependenciesFlag {
         + GetCPDFlag() : CheckProgrammingDependenciesFlagState
     }
@@ -122,13 +126,15 @@ object "runTest" as runTestType {
 }
 
 class AllowModeChangeService {
-    using AllowOpModeChangeOutput = std::uint8_t
+    using AllowOpModeChangeOutput = std::uint8_t;
+    + Func(const AllowOpModeChangeOutput input_1, std::shared_ptr<std::uint32_t> json_parser = nullptr) noexcept : static std::Result<Uptr>
 }
 
 ServiceImpl ..|> ServiceContract
 ChildInterface -up-|> BaseInterface
-StartResponsePayload +- ErrorInfo
+StartResponsePayload --> ErrorInfo
 StartResponsePayload o- ErrorInfo
+ServiceImpl "1" *-- "0..*" ErrorInfo
 CheckProgrammingDependenciesFlag -> CheckProgrammingDependenciesFlagState : uses
 FactoryFunctor --> ServiceImpl : creates
 
diff --git a/plantuml/parser/integration_test/class_diagram/class_diagram_unsupported_syntax/output.json b/plantuml/parser/integration_test/class_diagram/class_diagram_unsupported_syntax/output.json
index 4553723c..ad3039a2 100644
--- a/plantuml/parser/integration_test/class_diagram/class_diagram_unsupported_syntax/output.json
+++ b/plantuml/parser/integration_test/class_diagram/class_diagram_unsupported_syntax/output.json
@@ -5,68 +5,37 @@
       {
         "id": "GroupedA",
         "name": "GroupedA",
-        "alias": null,
-        "parent_id": null,
+        "enclosing_namespace_id": null,
         "entity_type": "Class",
-        "stereotypes": [],
-        "attributes": [],
+        "type_aliases": [],
         "methods": [],
-        "template_params": [],
+        "template_parameters": null,
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 21,
+        "variables": [],
+        "relationships": []
       },
       {
         "id": "GroupedB",
         "name": "GroupedB",
-        "alias": null,
-        "parent_id": null,
+        "enclosing_namespace_id": null,
         "entity_type": "Class",
-        "stereotypes": [],
-        "attributes": [],
+        "type_aliases": [],
         "methods": [],
-        "template_params": [],
+        "template_parameters": null,
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
-      },
-      {
-        "id": "sample.newline.FactoryFunctor",
-        "name": "FactoryFunctor",
-        "alias": "FactoryFunctor",
-        "parent_id": "sample.newline",
-        "entity_type": "Object",
-        "stereotypes": [],
-        "attributes": [],
-        "methods": [
-          {
-            "name": "operator()",
-            "return_type": null,
-            "visibility": "public",
-            "parameters": [],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
-          }
-        ],
-        "template_params": [],
-        "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 22,
+        "variables": [],
+        "relationships": []
       },
       {
         "id": "sample.newline.IActivateTask",
         "name": "IActivateTask",
-        "alias": null,
-        "parent_id": "sample.newline",
+        "enclosing_namespace_id": "sample.newline",
         "entity_type": "Interface",
-        "stereotypes": [],
-        "attributes": [],
+        "type_aliases": [],
         "methods": [
           {
             "name": "Execute",
@@ -76,181 +45,234 @@
               {
                 "name": "",
                 "param_type": "amp::stop_token",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               }
             ],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           }
         ],
-        "template_params": [],
+        "template_parameters": null,
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 39,
+        "variables": [],
+        "relationships": []
       },
       {
         "id": "sample.newline.BaseInterface",
         "name": "BaseInterface",
-        "alias": null,
-        "parent_id": "sample.newline",
+        "enclosing_namespace_id": "sample.newline",
         "entity_type": "Interface",
-        "stereotypes": [],
-        "attributes": [],
+        "type_aliases": [],
         "methods": [],
-        "template_params": [],
+        "template_parameters": null,
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 43,
+        "variables": [],
+        "relationships": []
       },
       {
         "id": "sample.newline.ChildInterface",
         "name": "ChildInterface",
-        "alias": null,
-        "parent_id": "sample.newline",
+        "enclosing_namespace_id": "sample.newline",
         "entity_type": "Interface",
-        "stereotypes": [],
-        "attributes": [],
+        "type_aliases": [],
         "methods": [],
-        "template_params": [],
+        "template_parameters": null,
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 45,
+        "variables": [],
+        "relationships": [
+          {
+            "source": "sample.newline.ChildInterface",
+            "target": "sample.newline.BaseInterface",
+            "relation_type": "Inheritance",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          },
+          {
+            "source": "sample.newline.ChildInterface",
+            "target": "sample.newline.BaseInterface",
+            "relation_type": "Inheritance",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          }
+        ]
       },
       {
         "id": "sample.newline.ServiceContract",
         "name": "ServiceContract",
-        "alias": null,
-        "parent_id": "sample.newline",
+        "enclosing_namespace_id": "sample.newline",
         "entity_type": "Interface",
-        "stereotypes": [],
-        "attributes": [],
+        "type_aliases": [],
         "methods": [],
-        "template_params": [],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 48,
+        "variables": [],
+        "relationships": []
+      },
+      {
+        "id": "sample.newline.myClass",
+        "name": "myClass",
+        "enclosing_namespace_id": "sample.newline",
+        "entity_type": "AbstractClass",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "func",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [],
+            "template_parameters": null,
+            "modifiers": [
+              "Abstract"
+            ]
+          }
+        ],
+        "template_parameters": null,
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 50,
+        "variables": [],
+        "relationships": []
       },
       {
         "id": "sample.newline.CheckProgrammingDependenciesFlag",
         "name": "CheckProgrammingDependenciesFlag",
-        "alias": null,
-        "parent_id": "sample.newline",
+        "enclosing_namespace_id": "sample.newline",
         "entity_type": "Interface",
-        "stereotypes": [],
-        "attributes": [],
+        "type_aliases": [],
         "methods": [
           {
             "name": "GetCPDFlag",
             "return_type": "CheckProgrammingDependenciesFlagState",
             "visibility": "public",
             "parameters": [],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           }
         ],
-        "template_params": [],
+        "template_parameters": null,
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 54,
+        "variables": [
+        ],
+        "relationships": [
+          {
+            "source": "sample.newline.CheckProgrammingDependenciesFlag",
+            "target": "sample.newline.CheckProgrammingDependenciesFlagState",
+            "relation_type": "Association",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          }
+        ]
       },
       {
         "id": "sample.newline.CheckProgrammingDependenciesFlagState",
-        "name": null,
-        "alias": null,
-        "parent_id": "sample.newline",
+        "name": "CheckProgrammingDependenciesFlagState",
+        "enclosing_namespace_id": "sample.newline",
         "entity_type": "Enum",
-        "stereotypes": [],
-        "attributes": [],
+        "type_aliases": [],
         "methods": [],
-        "template_params": [],
+        "template_parameters": null,
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 58,
+        "variables": [],
+        "relationships": []
       },
       {
         "id": "sample.newline.ErrorInfo",
-        "name": null,
-        "alias": null,
-        "parent_id": "sample.newline",
+        "name": "ErrorInfo",
+        "enclosing_namespace_id": "sample.newline",
         "entity_type": "Enum",
-        "stereotypes": [],
-        "attributes": [],
+        "type_aliases": [],
         "methods": [],
-        "template_params": [],
+        "template_parameters": null,
         "enum_literals": [
           {
             "name": "kUnspecified",
-            "visibility": "public",
-            "value": null,
-            "description": null
+            "value": null
           }
         ],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 60,
+        "variables": [],
+        "relationships": [
+          {
+            "source": "sample.newline.ErrorInfo",
+            "target": "sample.newline.StartResponsePayload",
+            "relation_type": "Aggregation",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          },
+          {
+            "source": "sample.newline.ErrorInfo",
+            "target": "sample.newline.ServiceImpl",
+            "relation_type": "Composition",
+            "source_multiplicity": "0..*",
+            "target_multiplicity": "1"
+          }
+        ]
       },
       {
         "id": "sample.newline.StartResponsePayload",
         "name": "StartResponsePayload",
-        "alias": null,
-        "parent_id": "sample.newline",
+        "enclosing_namespace_id": "sample.newline",
         "entity_type": "Struct",
-        "stereotypes": [],
-        "attributes": [
+        "type_aliases": [],
+        "methods": [],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 64,
+        "variables": [
           {
             "name": "ErrorInfo",
             "data_type": null,
             "visibility": "public",
-            "default_value": null,
             "is_static": false,
-            "is_const": false,
-            "description": null
+            "is_const": false
           }
         ],
-        "methods": [],
-        "template_params": [],
-        "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "relationships": [
+          {
+            "source": "sample.newline.StartResponsePayload",
+            "target": "sample.newline.ErrorInfo",
+            "relation_type": "Association",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          }
+        ]
       },
       {
         "id": "sample.newline.GenericClass",
         "name": "GenericClass",
-        "alias": null,
-        "parent_id": "sample.newline",
+        "enclosing_namespace_id": "sample.newline",
         "entity_type": "Class",
-        "stereotypes": [],
-        "attributes": [],
+        "type_aliases": [],
         "methods": [],
-        "template_params": [
+        "template_parameters": [
           "T"
         ],
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 68,
+        "variables": [],
+        "relationships": []
       },
       {
         "id": "sample.newline.DiagnosticJobCollectionBuilder",
         "name": "DiagnosticJobCollectionBuilder",
-        "alias": null,
-        "parent_id": "sample.newline",
+        "enclosing_namespace_id": "sample.newline",
         "entity_type": "Class",
-        "stereotypes": [],
-        "attributes": [],
+        "type_aliases": [],
         "methods": [
           {
             "name": "With",
@@ -260,45 +282,33 @@
               {
                 "name": "",
                 "param_type": "::ara::core::InstanceSpecifier",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "",
                 "param_type": "DiagnosticJobConstructorArgumentTypes",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": true
               }
             ],
-            "template_params": [
+            "template_parameters": [
               "DiagnosticJobType"
             ],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "modifiers": []
           }
         ],
-        "template_params": [],
+        "template_parameters": null,
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 71,
+        "variables": [],
+        "relationships": []
       },
       {
         "id": "sample.newline.SoftwareEntityTable",
         "name": "SoftwareEntityTable",
-        "alias": null,
-        "parent_id": "sample.newline",
+        "enclosing_namespace_id": "sample.newline",
         "entity_type": "Class",
-        "stereotypes": [],
-        "attributes": [],
+        "type_aliases": [],
         "methods": [
           {
             "name": "SetFingerprint",
@@ -308,114 +318,66 @@
               {
                 "name": "year",
                 "param_type": "uint8",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "month",
                 "param_type": "uint8",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "day",
                 "param_type": "uint8",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "len_and_tester_id",
                 "param_type": "uint8",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "reserved",
                 "param_type": "array<uint8, 9>",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               }
             ],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           }
         ],
-        "template_params": [],
+        "template_parameters": null,
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 75,
+        "variables": [],
+        "relationships": []
       },
       {
         "id": "sample.newline.ServiceImpl",
         "name": "ServiceImpl",
-        "alias": null,
-        "parent_id": "sample.newline",
+        "enclosing_namespace_id": "sample.newline",
         "entity_type": "Class",
-        "stereotypes": [],
-        "attributes": [
-          {
-            "name": "config_",
-            "data_type": "Config",
-            "visibility": "private",
-            "default_value": null,
-            "is_static": false,
-            "is_const": false,
-            "description": null
-          },
-          {
-            "name": "non_fatal_errors",
-            "data_type": "{test::result::Error}",
-            "visibility": "public",
-            "default_value": null,
-            "is_static": false,
-            "is_const": false,
-            "description": null
-          }
-        ],
+        "type_aliases": [],
         "methods": [
           {
             "name": "Run",
             "return_type": "ResultBlank",
             "visibility": "public",
             "parameters": [],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": true,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": [
+              "Abstract"
+            ]
           },
           {
             "name": "Finalize",
             "return_type": null,
             "visibility": "public",
             "parameters": [],
-            "template_params": [],
-            "is_static": true,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": [
+              "Static"
+            ]
           },
           {
             "name": "Submit",
@@ -425,48 +387,29 @@
               {
                 "name": "callable",
                 "param_type": null,
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               }
             ],
-            "template_params": [],
-            "is_static": false,
-            "is_const": true,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           },
           {
             "name": "Build",
             "return_type": null,
             "visibility": "public",
             "parameters": [],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           },
           {
             "name": "~ServiceImpl",
             "return_type": null,
             "visibility": "public",
             "parameters": [],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": true
+            "template_parameters": null,
+            "modifiers": [
+              "Destructor"
+            ]
           },
           {
             "name": "operator()",
@@ -476,20 +419,11 @@
               {
                 "name": "",
                 "param_type": "amp::stop_token",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               }
             ],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           },
           {
             "name": "Submit",
@@ -499,31 +433,19 @@
               {
                 "name": "callable",
                 "param_type": null,
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "arguments",
                 "param_type": null,
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               }
             ],
-            "template_params": [
+            "template_parameters": [
               "CallableType",
               "ArgumentTypes..."
             ],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "modifiers": []
           },
           {
             "name": "Submit",
@@ -533,72 +455,42 @@
               {
                 "name": "",
                 "param_type": "CallableType&&",
-                "default_value": null,
-                "is_reference": true,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "",
                 "param_type": "ArgumentTypes&&",
-                "default_value": null,
-                "is_reference": true,
-                "is_const": false,
                 "is_variadic": false
               }
             ],
-            "template_params": [
+            "template_parameters": [
               "T"
             ],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "modifiers": []
           },
           {
             "name": "GetActiveSWEs",
             "return_type": "SoftwareEntityTable&",
             "visibility": "public",
             "parameters": [],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           },
           {
             "name": "TakeOwnership",
             "return_type": "Artifact&&",
             "visibility": "public",
             "parameters": [],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           },
           {
             "name": "operator->",
             "return_type": "Result<Artifact>*",
             "visibility": "public",
             "parameters": [],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           },
           {
             "name": "run_application",
@@ -608,20 +500,11 @@
               {
                 "name": "argv",
                 "param_type": "[]test::StringLiteral",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               }
             ],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           },
           {
             "name": "Visit",
@@ -631,20 +514,11 @@
               {
                 "name": "visitor",
                 "param_type": "amp::callback<void(Flashing&)>",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               }
             ],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           },
           {
             "name": "VisitUnnamed",
@@ -654,20 +528,11 @@
               {
                 "name": "",
                 "param_type": "amp::callback<void(FlashingMinion&)>",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               }
             ],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           },
           {
             "name": "CreateJobs",
@@ -677,36 +542,21 @@
               {
                 "name": "",
                 "param_type": "const amp::stop_token&",
-                "default_value": null,
-                "is_reference": true,
-                "is_const": true,
                 "is_variadic": false
               },
               {
                 "name": "",
                 "param_type": "InfrastructureContext",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "",
                 "param_type": "Context",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               }
             ],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           },
           {
             "name": "ChangeHandler",
@@ -716,84 +566,86 @@
               {
                 "name": "",
                 "param_type": "amp::pmr::unique_ptr<ExecutorFactory>",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "",
                 "param_type": "std::shared_ptr<mw::diag::IConversations>",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               }
             ],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           }
         ],
-        "template_params": [],
+        "template_parameters": null,
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 79,
+        "variables": [
+          {
+            "name": "config_",
+            "data_type": "Config",
+            "visibility": "private",
+            "is_static": false,
+            "is_const": false
+          },
+          {
+            "name": "non_fatal_errors",
+            "data_type": "{test::result::Error}",
+            "visibility": "public",
+            "is_static": false,
+            "is_const": false
+          }
+        ],
+        "relationships": [
+          {
+            "source": "sample.newline.ServiceImpl",
+            "target": "sample.newline.ServiceContract",
+            "relation_type": "Implementation",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          },
+          {
+            "source": "sample.newline.ServiceImpl",
+            "target": "sample.newline.ServiceContract",
+            "relation_type": "Implementation",
+            "source_multiplicity": null,
+            "target_multiplicity": null
+          }
+        ]
       },
       {
         "id": "sample.newline.<<template>>\\nTest<T>",
-        "name": "<<template>>\\nTest<T>",
-        "alias": "TestTemplate",
-        "parent_id": "sample.newline",
+        "name": "TestTemplate",
+        "enclosing_namespace_id": "sample.newline",
         "entity_type": "Class",
-        "stereotypes": [],
-        "attributes": [],
+        "type_aliases": [],
         "methods": [
           {
             "name": "Bind",
             "return_type": null,
             "visibility": "public",
             "parameters": [],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           }
         ],
-        "template_params": [
+        "template_parameters": [
           "T"
         ],
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 111,
+        "variables": [],
+        "relationships": []
       },
       {
         "id": "TestMethod",
         "name": "TestMethod",
-        "alias": null,
-        "parent_id": null,
+        "enclosing_namespace_id": null,
         "entity_type": "Class",
-        "stereotypes": [],
-        "attributes": [
-          {
-            "name": "",
-            "data_type": "std::mutex",
-            "visibility": "private",
-            "default_value": null,
-            "is_static": false,
-            "is_const": false,
-            "description": null
-          }
-        ],
+        "type_aliases": [],
         "methods": [
           {
             "name": "Test",
@@ -803,155 +655,93 @@
               {
                 "name": "callable",
                 "param_type": null,
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "on_success",
                 "param_type": null,
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "timeout",
                 "param_type": null,
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "stop_token",
                 "param_type": null,
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "minion_id",
                 "param_type": null,
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               },
               {
                 "name": "retries",
                 "param_type": null,
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
                 "is_variadic": false
               }
             ],
-            "template_params": [],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": []
           }
         ],
-        "template_params": [],
+        "template_parameters": null,
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 116,
+        "variables": [
+          {
+            "name": "",
+            "data_type": "std::mutex",
+            "visibility": "private",
+            "is_static": false,
+            "is_const": false
+          }
+        ],
+        "relationships": []
       },
       {
-        "id": "runTest",
-        "name": "runTest",
-        "alias": "runTestType",
-        "parent_id": null,
-        "entity_type": "Object",
-        "stereotypes": [],
-        "attributes": [],
+        "id": "AllowModeChangeService",
+        "name": "AllowModeChangeService",
+        "enclosing_namespace_id": null,
+        "entity_type": "Class",
+        "type_aliases": [
+          {
+            "alias": "AllowOpModeChangeOutput",
+            "original_type": "std::uint8_t"
+          }
+        ],
         "methods": [
           {
-            "name": "run",
-            "return_type": "std::int32_t",
+            "name": "Func",
+            "return_type": "std::Result<Uptr>",
             "visibility": "public",
             "parameters": [
               {
-                "name": "argc",
-                "param_type": "std::int32_t",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
+                "name": "input_1",
+                "param_type": "const AllowOpModeChangeOutput",
                 "is_variadic": false
               },
               {
-                "name": "argv",
-                "param_type": "[]std::uint8_t",
-                "default_value": null,
-                "is_reference": false,
-                "is_const": false,
+                "name": "json_parser",
+                "param_type": "std::shared_ptr<std::uint32_t>",
                 "is_variadic": false
-              },
-              {
-                "name": "args",
-                "param_type": "Args&&",
-                "default_value": null,
-                "is_reference": true,
-                "is_const": false,
-                "is_variadic": true
               }
             ],
-            "template_params": [
-              "Param1",
-              "Args..."
-            ],
-            "is_static": false,
-            "is_const": false,
-            "is_virtual": false,
-            "is_abstract": false,
-            "is_override": false,
-            "is_constructor": false,
-            "is_destructor": false
+            "template_parameters": null,
+            "modifiers": [
+              "Static"
+            ]
           }
         ],
-        "template_params": [],
+        "template_parameters": null,
         "enum_literals": [],
-        "source_file": null,
-        "source_line": null
-      },
-      {
-        "id": "AllowModeChangeService",
-        "name": "AllowModeChangeService",
-        "alias": null,
-        "parent_id": null,
-        "entity_type": "Class",
-        "stereotypes": [],
-        "attributes": [
-          {
-            "name": "AllowOpModeChangeOutput",
-            "data_type": "std::uint8_t",
-            "visibility": "public",
-            "default_value": null,
-            "is_static": false,
-            "is_const": false,
-            "description": null
-          }
-        ],
-        "methods": [],
-        "template_params": [],
-        "enum_literals": [],
-        "source_file": null,
-        "source_line": null
-      }
-    ],
-    "containers": [
-      {
-        "id": "sample.newline",
-        "name": "sample::newline",
-        "parent_id": null,
-        "container_type": "Package"
+        "source_file": "class_diagram_unsupported_syntax",
+        "source_line": 128,
+        "variables": [],
+        "relationships": []
       }
     ],
     "relationships": [
@@ -959,89 +749,57 @@
         "source": "sample.newline.ChildInterface",
         "target": "sample.newline.BaseInterface",
         "relation_type": "Inheritance",
-        "label": null,
-        "stereotype": null,
         "source_multiplicity": null,
-        "target_multiplicity": null,
-        "source_role": null,
-        "target_role": null
+        "target_multiplicity": null
       },
       {
         "source": "sample.newline.ServiceImpl",
         "target": "sample.newline.ServiceContract",
         "relation_type": "Implementation",
-        "label": null,
-        "stereotype": null,
         "source_multiplicity": null,
-        "target_multiplicity": null,
-        "source_role": null,
-        "target_role": null
+        "target_multiplicity": null
       },
       {
         "source": "sample.newline.ServiceImpl",
         "target": "sample.newline.ServiceContract",
         "relation_type": "Implementation",
-        "label": null,
-        "stereotype": null,
         "source_multiplicity": null,
-        "target_multiplicity": null,
-        "source_role": null,
-        "target_role": null
+        "target_multiplicity": null
       },
       {
         "source": "sample.newline.ChildInterface",
         "target": "sample.newline.BaseInterface",
         "relation_type": "Inheritance",
-        "label": null,
-        "stereotype": null,
         "source_multiplicity": null,
-        "target_multiplicity": null,
-        "source_role": null,
-        "target_role": null
+        "target_multiplicity": null
       },
       {
         "source": "sample.newline.StartResponsePayload",
         "target": "sample.newline.ErrorInfo",
-        "relation_type": "Link",
-        "label": null,
-        "stereotype": null,
+        "relation_type": "Association",
         "source_multiplicity": null,
-        "target_multiplicity": null,
-        "source_role": null,
-        "target_role": null
+        "target_multiplicity": null
       },
       {
         "source": "sample.newline.ErrorInfo",
         "target": "sample.newline.StartResponsePayload",
         "relation_type": "Aggregation",
-        "label": null,
-        "stereotype": null,
         "source_multiplicity": null,
-        "target_multiplicity": null,
-        "source_role": null,
-        "target_role": null
+        "target_multiplicity": null
       },
       {
-        "source": "sample.newline.CheckProgrammingDependenciesFlag",
-        "target": "sample.newline.CheckProgrammingDependenciesFlagState",
-        "relation_type": "Association",
-        "label": "uses",
-        "stereotype": null,
-        "source_multiplicity": null,
-        "target_multiplicity": null,
-        "source_role": null,
-        "target_role": null
+        "source": "sample.newline.ErrorInfo",
+        "target": "sample.newline.ServiceImpl",
+        "relation_type": "Composition",
+        "source_multiplicity": "0..*",
+        "target_multiplicity": "1"
       },
       {
-        "source": "sample.newline.FactoryFunctor",
-        "target": "sample.newline.ServiceImpl",
+        "source": "sample.newline.CheckProgrammingDependenciesFlag",
+        "target": "sample.newline.CheckProgrammingDependenciesFlagState",
         "relation_type": "Association",
-        "label": "creates",
-        "stereotype": null,
         "source_multiplicity": null,
-        "target_multiplicity": null,
-        "source_role": null,
-        "target_role": null
+        "target_multiplicity": null
       }
     ],
     "source_files": [
diff --git a/plantuml/parser/integration_test/src/test_error_view.rs b/plantuml/parser/integration_test/src/test_error_view.rs
index b8cb5805..804f63c1 100644
--- a/plantuml/parser/integration_test/src/test_error_view.rs
+++ b/plantuml/parser/integration_test/src/test_error_view.rs
@@ -13,12 +13,11 @@
 use std::collections::HashMap;
 use std::path::Path;
 
-use class_diagram::ClassResolverError;
 use puml_parser::{
     BaseParseError, ClassError, IncludeExpandError, IncludeParseError, PreprocessError,
     ProcedureExpandError, ProcedureParseError,
 };
-use puml_resolver::ComponentResolverError;
+use puml_resolver::{ClassPumlResolverError, ComponentResolverError};
 
 #[derive(Debug)]
 pub struct ProjectedError {
@@ -186,6 +185,14 @@ impl ErrorView for ClassError {
     fn project(&self, base_dir: &Path) -> ProjectedError {
         match self {
             ClassError::Base(e) => e.project(base_dir),
+            ClassError::UnexpectedUsingAttribute => {
+                let _ = base_dir;
+                ProjectedError::new("UnexpectedUsingAttribute")
+            }
+            ClassError::UnexpectedClassMember(rule) => {
+                let _ = base_dir;
+                ProjectedError::new("UnexpectedClassMember").with_field("rule", rule.clone())
+            }
         }
     }
 }
@@ -211,39 +218,39 @@ impl ErrorView for ComponentResolverError {
     }
 }
 
-impl ErrorView for ClassResolverError {
+impl ErrorView for ClassPumlResolverError {
     fn project(&self, _base_dir: &Path) -> ProjectedError {
         match self {
-            ClassResolverError::UnresolvedReference { reference } => {
+            ClassPumlResolverError::UnresolvedReference { reference } => {
                 ProjectedError::new("UnresolvedReference")
                     .with_field("reference", reference.clone())
             }
 
-            ClassResolverError::DuplicateEntity { entity_id } => {
+            ClassPumlResolverError::DuplicateEntity { entity_id } => {
                 ProjectedError::new("DuplicateEntity").with_field("entity_id", entity_id.clone())
             }
 
-            ClassResolverError::UnknownEntityType { entity_type } => {
+            ClassPumlResolverError::UnknownEntityType { entity_type } => {
                 ProjectedError::new("UnknownEntityType")
                     .with_field("entity_type", entity_type.clone())
             }
 
-            ClassResolverError::InvalidRelationship { from, to, reason } => {
+            ClassPumlResolverError::InvalidRelationship { from, to, reason } => {
                 ProjectedError::new("InvalidRelationship")
                     .with_field("from", from.clone())
                     .with_field("to", to.clone())
                     .with_field("reason", reason.clone())
             }
 
-            ClassResolverError::CircularInheritance { cycle } => {
+            ClassPumlResolverError::CircularInheritance { cycle } => {
                 ProjectedError::new("CircularInheritance").with_field("cycle", cycle.clone())
             }
 
-            ClassResolverError::InvalidVisibility { modifier } => {
+            ClassPumlResolverError::InvalidVisibility { modifier } => {
                 ProjectedError::new("InvalidVisibility").with_field("modifier", modifier.clone())
             }
 
-            ClassResolverError::ParseError { message } => {
+            ClassPumlResolverError::ParseError { message } => {
                 ProjectedError::new("ParseError").with_field("message", message.clone())
             }
         }
diff --git a/plantuml/parser/puml_lobster/src/lib.rs b/plantuml/parser/puml_lobster/src/lib.rs
index a3a5cacb..3c388620 100644
--- a/plantuml/parser/puml_lobster/src/lib.rs
+++ b/plantuml/parser/puml_lobster/src/lib.rs
@@ -121,11 +121,9 @@ fn map_entity_type_to_kind(entity_type: EntityType) -> &'static str {
     match entity_type {
         EntityType::Class => "Class",
         EntityType::Struct => "Struct",
-        EntityType::Object => "Object",
         EntityType::Interface => "Interface",
         EntityType::Enum => "Enum",
         EntityType::AbstractClass => "AbstractClass",
-        EntityType::Annotation => "Annotation",
     }
 }
 
diff --git a/plantuml/parser/puml_parser/src/class_diagram/src/class_ast.rs b/plantuml/parser/puml_parser/src/class_diagram/src/class_ast.rs
index 984e2d0d..8c4b22a2 100644
--- a/plantuml/parser/puml_parser/src/class_diagram/src/class_ast.rs
+++ b/plantuml/parser/puml_parser/src/class_diagram/src/class_ast.rs
@@ -30,7 +30,6 @@ pub enum Element {
     StructDef(StructDef),
     EnumDef(EnumDef),
     InterfaceDef(InterfaceDef),
-    ObjectDef(ObjectDef),
 }
 impl Element {
     pub fn set_namespace(&mut self, ns: String) {
@@ -39,7 +38,6 @@ impl Element {
             Element::StructDef(def) => def.namespace = ns,
             Element::EnumDef(def) => def.namespace = ns,
             Element::InterfaceDef(def) => def.namespace = ns,
-            Element::ObjectDef(def) => def.namespace = ns,
         }
     }
     pub fn set_package(&mut self, ns: String) {
@@ -48,7 +46,6 @@ impl Element {
             Element::StructDef(def) => def.package = ns,
             Element::EnumDef(def) => def.package = ns,
             Element::InterfaceDef(def) => def.package = ns,
-            Element::ObjectDef(def) => def.package = ns,
         }
     }
 }
@@ -84,6 +81,8 @@ pub struct Relationship {
     pub left: String,
     pub right: String,
     pub arrow: Arrow,
+    pub left_multiplicity: Option<String>,
+    pub right_multiplicity: Option<String>,
     pub label: Option<String>,
 }
 
@@ -99,7 +98,6 @@ pub struct Attribute {
     pub visibility: Visibility,
     pub name: String,
     pub r#type: Option<String>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub modifiers: Vec<String>,
 }
 impl Default for Attribute {
@@ -113,14 +111,19 @@ impl Default for Attribute {
     }
 }
 
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Default)]
+pub struct TypeAlias {
+    pub alias: String,
+    pub original_type: String,
+}
+
 #[derive(Debug, Serialize, Deserialize, PartialEq)]
 pub struct Method {
     pub visibility: Visibility,
     pub name: String,
-    pub generic_params: Vec<String>,
+    pub template_parameters: Option<Vec<String>>,
     pub params: Vec<Param>,
     pub r#type: Option<String>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub modifiers: Vec<String>,
 }
 impl Default for Method {
@@ -128,7 +131,7 @@ impl Default for Method {
         Method {
             visibility: Visibility::Public,
             name: String::new(),
-            generic_params: Vec::new(),
+            template_parameters: None,
             params: Vec::new(),
             r#type: None,
             modifiers: Vec::new(),
@@ -141,13 +144,13 @@ pub struct ClassDef {
     pub name: Name,
     pub namespace: String,
     pub package: String,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub template_params: Vec<String>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub source_line: Option<u32>,
+    pub is_abstract: bool,
+    pub template_parameters: Option<Vec<String>>,
     pub extends: Vec<String>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub implements: Vec<String>,
     pub attributes: Vec<Attribute>,
+    pub type_aliases: Vec<TypeAlias>,
     pub methods: Vec<Method>,
 }
 impl TypeDef for ClassDef {
@@ -159,9 +162,17 @@ impl TypeDef for ClassDef {
         &mut self.attributes
     }
 
+    fn type_aliases_mut(&mut self) -> &mut Vec<TypeAlias> {
+        &mut self.type_aliases
+    }
+
     fn methods_mut(&mut self) -> &mut Vec<Method> {
         &mut self.methods
     }
+
+    fn source_line_mut(&mut self) -> &mut Option<u32> {
+        &mut self.source_line
+    }
 }
 
 #[derive(Debug, Default, Serialize, Deserialize, PartialEq)]
@@ -169,9 +180,10 @@ pub struct StructDef {
     pub name: Name,
     pub namespace: String,
     pub package: String,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub template_params: Vec<String>,
+    pub source_line: Option<u32>,
+    pub template_parameters: Option<Vec<String>>,
     pub attributes: Vec<Attribute>,
+    pub type_aliases: Vec<TypeAlias>,
     pub methods: Vec<Method>,
 }
 impl TypeDef for StructDef {
@@ -183,9 +195,17 @@ impl TypeDef for StructDef {
         &mut self.attributes
     }
 
+    fn type_aliases_mut(&mut self) -> &mut Vec<TypeAlias> {
+        &mut self.type_aliases
+    }
+
     fn methods_mut(&mut self) -> &mut Vec<Method> {
         &mut self.methods
     }
+
+    fn source_line_mut(&mut self) -> &mut Option<u32> {
+        &mut self.source_line
+    }
 }
 
 #[derive(Debug, Default, Serialize, Deserialize, PartialEq)]
@@ -193,11 +213,11 @@ pub struct InterfaceDef {
     pub name: Name,
     pub namespace: String,
     pub package: String,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub template_params: Vec<String>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub source_line: Option<u32>,
+    pub template_parameters: Option<Vec<String>>,
     pub extends: Vec<String>,
     pub attributes: Vec<Attribute>,
+    pub type_aliases: Vec<TypeAlias>,
     pub methods: Vec<Method>,
 }
 impl TypeDef for InterfaceDef {
@@ -209,33 +229,17 @@ impl TypeDef for InterfaceDef {
         &mut self.attributes
     }
 
-    fn methods_mut(&mut self) -> &mut Vec<Method> {
-        &mut self.methods
-    }
-}
-
-#[derive(Debug, Default, Serialize, Deserialize, PartialEq)]
-pub struct ObjectDef {
-    pub name: Name,
-    pub namespace: String,
-    pub package: String,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub template_params: Vec<String>,
-    pub attributes: Vec<Attribute>,
-    pub methods: Vec<Method>,
-}
-impl TypeDef for ObjectDef {
-    fn name_mut(&mut self) -> &mut Name {
-        &mut self.name
-    }
-
-    fn attributes_mut(&mut self) -> &mut Vec<Attribute> {
-        &mut self.attributes
+    fn type_aliases_mut(&mut self) -> &mut Vec<TypeAlias> {
+        &mut self.type_aliases
     }
 
     fn methods_mut(&mut self) -> &mut Vec<Method> {
         &mut self.methods
     }
+
+    fn source_line_mut(&mut self) -> &mut Option<u32> {
+        &mut self.source_line
+    }
 }
 
 #[derive(Debug, Default, Serialize, Deserialize, PartialEq)]
@@ -243,13 +247,13 @@ pub struct EnumDef {
     pub name: Name,
     pub namespace: String,
     pub package: String,
+    pub source_line: Option<u32>,
     pub stereotypes: Vec<String>,
     pub items: Vec<EnumItem>,
 }
 
 #[derive(Debug, Default, Serialize, Deserialize, PartialEq)]
 pub struct EnumItem {
-    pub visibility: Option<Visibility>,
     pub name: String,
     pub value: Option<EnumValue>,
 }
@@ -344,7 +348,7 @@ mod tests {
 
         assert_eq!(method.visibility, Visibility::Public);
         assert_eq!(method.name, "");
-        assert!(method.generic_params.is_empty());
+        assert_eq!(method.template_parameters, None);
         assert!(method.params.is_empty());
         assert_eq!(method.r#type, None);
         assert!(method.modifiers.is_empty());
@@ -379,6 +383,8 @@ mod tests {
                 middle: None,
                 right: None,
             },
+            left_multiplicity: None,
+            right_multiplicity: None,
             label: None,
         });
 
@@ -391,7 +397,6 @@ mod tests {
 
         enum_def.name.internal = "Color".into();
         enum_def.items.push(EnumItem {
-            visibility: Some(Visibility::Public),
             name: "RED".into(),
             value: Some(EnumValue::Literal("1".into())),
         });
@@ -427,6 +432,8 @@ mod tests {
                 middle: None,
                 right: None,
             },
+            left_multiplicity: None,
+            right_multiplicity: None,
             label: Some("uses".into()),
         });
 
@@ -440,7 +447,6 @@ mod tests {
             Element::StructDef(StructDef::default()),
             Element::EnumDef(EnumDef::default()),
             Element::InterfaceDef(InterfaceDef::default()),
-            Element::ObjectDef(ObjectDef::default()),
         ];
 
         for el in elements.iter_mut() {
@@ -453,7 +459,6 @@ mod tests {
                 Element::StructDef(d) => assert_eq!(d.namespace, "test_ns"),
                 Element::EnumDef(d) => assert_eq!(d.namespace, "test_ns"),
                 Element::InterfaceDef(d) => assert_eq!(d.namespace, "test_ns"),
-                Element::ObjectDef(d) => assert_eq!(d.namespace, "test_ns"),
             }
         }
     }
@@ -483,6 +488,19 @@ mod tests {
         assert_eq!(class.attributes.len(), 1);
     }
 
+    #[test]
+    fn test_type_aliases_mut() {
+        let mut class = ClassDef::default();
+
+        class.type_aliases_mut().push(TypeAlias {
+            alias: "Byte".into(),
+            original_type: "std::uint8_t".into(),
+        });
+
+        assert_eq!(class.type_aliases.len(), 1);
+        assert_eq!(class.type_aliases[0].alias, "Byte");
+    }
+
     #[test]
     fn test_name_mut() {
         let mut class = ClassDef::default();
@@ -522,15 +540,6 @@ mod tests {
         assert_eq!(i.methods.len(), 1);
     }
 
-    #[test]
-    fn test_object_methods_mut() {
-        let mut object = ObjectDef::default();
-
-        object.methods_mut().push(Method::default());
-
-        assert_eq!(object.methods.len(), 1);
-    }
-
     #[test]
     fn test_typedef_trait_object_calls_for_class_def() {
         use crate::class_traits::TypeDef;
@@ -545,6 +554,10 @@ mod tests {
                 name: "field".into(),
                 ..Default::default()
             });
+            obj.type_aliases_mut().push(TypeAlias {
+                alias: "Byte".into(),
+                original_type: "std::uint8_t".into(),
+            });
             obj.methods_mut().push(Method {
                 name: "method".into(),
                 ..Default::default()
@@ -554,6 +567,8 @@ mod tests {
         assert_eq!(c.name.internal, "ClassViaTrait");
         assert_eq!(c.attributes.len(), 1);
         assert_eq!(c.attributes[0].name, "field");
+        assert_eq!(c.type_aliases.len(), 1);
+        assert_eq!(c.type_aliases[0].alias, "Byte");
         assert_eq!(c.methods.len(), 1);
         assert_eq!(c.methods[0].name, "method");
     }
@@ -572,6 +587,10 @@ mod tests {
                 name: "field".into(),
                 ..Default::default()
             });
+            obj.type_aliases_mut().push(TypeAlias {
+                alias: "Byte".into(),
+                original_type: "std::uint8_t".into(),
+            });
             obj.methods_mut().push(Method {
                 name: "method".into(),
                 ..Default::default()
@@ -581,6 +600,8 @@ mod tests {
         assert_eq!(s.name.internal, "StructViaTrait");
         assert_eq!(s.attributes.len(), 1);
         assert_eq!(s.attributes[0].name, "field");
+        assert_eq!(s.type_aliases.len(), 1);
+        assert_eq!(s.type_aliases[0].alias, "Byte");
         assert_eq!(s.methods.len(), 1);
         assert_eq!(s.methods[0].name, "method");
     }
@@ -599,6 +620,10 @@ mod tests {
                 name: "field".into(),
                 ..Default::default()
             });
+            obj.type_aliases_mut().push(TypeAlias {
+                alias: "Byte".into(),
+                original_type: "std::uint8_t".into(),
+            });
             obj.methods_mut().push(Method {
                 name: "method".into(),
                 ..Default::default()
@@ -608,37 +633,12 @@ mod tests {
         assert_eq!(i.name.internal, "InterfaceViaTrait");
         assert_eq!(i.attributes.len(), 1);
         assert_eq!(i.attributes[0].name, "field");
+        assert_eq!(i.type_aliases.len(), 1);
+        assert_eq!(i.type_aliases[0].alias, "Byte");
         assert_eq!(i.methods.len(), 1);
         assert_eq!(i.methods[0].name, "method");
     }
 
-    #[test]
-    fn test_typedef_trait_object_calls_for_object_def() {
-        use crate::class_traits::TypeDef;
-
-        let mut object = ObjectDef::default();
-
-        {
-            let obj: &mut dyn TypeDef = &mut object;
-
-            obj.name_mut().internal = "ObjectViaTrait".into();
-            obj.attributes_mut().push(Attribute {
-                name: "field".into(),
-                ..Default::default()
-            });
-            obj.methods_mut().push(Method {
-                name: "method".into(),
-                ..Default::default()
-            });
-        }
-
-        assert_eq!(object.name.internal, "ObjectViaTrait");
-        assert_eq!(object.attributes.len(), 1);
-        assert_eq!(object.attributes[0].name, "field");
-        assert_eq!(object.methods.len(), 1);
-        assert_eq!(object.methods[0].name, "method");
-    }
-
     #[test]
     fn test_class_uml_file_supports_generic_as_ref_usage() {
         fn use_as_ref<T: AsRef<str>>(v: T) -> String {
diff --git a/plantuml/parser/puml_parser/src/class_diagram/src/class_parser.rs b/plantuml/parser/puml_parser/src/class_diagram/src/class_parser.rs
index faf82408..46ca19db 100644
--- a/plantuml/parser/puml_parser/src/class_diagram/src/class_parser.rs
+++ b/plantuml/parser/puml_parser/src/class_diagram/src/class_parser.rs
@@ -12,17 +12,18 @@
 // *******************************************************************************
 use crate::class_ast::{
     Arrow, Attribute, ClassDef, ClassUmlFile, ClassUmlTopLevel, Element, EnumDef, EnumItem,
-    EnumValue, InterfaceDef, Method, Name, Namespace, ObjectDef, Package, Param, Relationship,
-    StructDef, Visibility,
+    EnumValue, InterfaceDef, Method, Name, Namespace, Package, Param, Relationship, StructDef,
+    TypeAlias, Visibility,
 };
 use crate::class_traits::{TypeDef, WritableName};
 use crate::source_map::{
-    normalize_multiline_member_signatures, remap_syntax_error_to_original_source,
+    normalize_multiline_member_signatures, remap_syntax_error_to_original_source, NormalizedContent,
 };
 use parser_core::common_parser::{parse_arrow, PlantUmlCommonParser, Rule};
 use parser_core::{pest_to_syntax_error, BaseParseError, DiagramParser};
 use pest::Parser;
 use puml_utils::LogLevel;
+use std::collections::HashSet;
 use std::path::PathBuf;
 use std::rc::Rc;
 use thiserror::Error;
@@ -31,6 +32,70 @@ use thiserror::Error;
 pub enum ClassError {
     #[error(transparent)]
     Base(#[from] BaseParseError<Rule>),
+    #[error("encountered using attribute while parsing a class attribute")]
+    UnexpectedUsingAttribute,
+    #[error("unexpected class member rule: {0}")]
+    UnexpectedClassMember(String),
+}
+
+// Object definitions are ignored by the class parser, but their names must be
+// tracked long enough to drop relationships that reference those ignored objects.
+#[derive(Debug, Default)]
+struct IgnoredObjectRegistry {
+    ids: HashSet<String>,
+    names: HashSet<String>,
+}
+
+impl IgnoredObjectRegistry {
+    fn normalize_fqn(raw: &str) -> String {
+        raw.replace("::", ".").trim_matches('.').to_string()
+    }
+
+    fn build_fqn(name: &str, parent: &Option<String>) -> String {
+        let normalized_name = Self::normalize_fqn(name);
+
+        match parent {
+            Some(p) => {
+                let normalized_parent = Self::normalize_fqn(p);
+
+                if normalized_parent.is_empty() {
+                    normalized_name
+                } else if normalized_name.is_empty() {
+                    normalized_parent
+                } else {
+                    format!("{}.{}", normalized_parent, normalized_name)
+                }
+            }
+            None => normalized_name,
+        }
+    }
+
+    fn register(&mut self, name: &Name, parent: &Option<String>) {
+        self.ids.insert(Self::build_fqn(&name.internal, parent));
+        self.names.insert(name.internal.clone());
+
+        if let Some(alias) = &name.display {
+            self.names.insert(alias.clone());
+        }
+    }
+
+    fn merge(&mut self, other: Self) {
+        self.ids.extend(other.ids);
+        self.names.extend(other.names);
+    }
+
+    fn contains_reference(&self, name: &str, parent: &Option<String>) -> bool {
+        let normalized = Self::normalize_fqn(name);
+
+        self.ids.contains(&normalized)
+            || self.ids.contains(&Self::build_fqn(name, parent))
+            || self.names.contains(name)
+    }
+
+    fn filters_relationship(&self, relationship: &Relationship, parent: &Option<String>) -> bool {
+        self.contains_reference(&relationship.left, parent)
+            || self.contains_reference(&relationship.right, parent)
+    }
 }
 
 fn parse_visibility(pair: Option<pest::iterators::Pair<Rule>>) -> Visibility {
@@ -103,7 +168,7 @@ fn parse_named(pair: pest::iterators::Pair<Rule>, name: &mut Name) {
     }
 }
 
-fn parse_attribute(pair: pest::iterators::Pair<Rule>) -> Attribute {
+fn parse_attribute(pair: pest::iterators::Pair<Rule>) -> Result<Attribute, ClassError> {
     let mut attr = Attribute::default();
     let mut vis = None;
     let mut name = None;
@@ -113,15 +178,7 @@ fn parse_attribute(pair: pest::iterators::Pair<Rule>) -> Attribute {
         match p.as_rule() {
             Rule::static_modifier => attr.modifiers.push(p.as_str().to_string()),
             Rule::class_visibility => vis = Some(p),
-            Rule::using_attribute => {
-                for inner in p.into_inner() {
-                    match inner.as_rule() {
-                        Rule::identifier => name = Some(inner.as_str().to_string()),
-                        Rule::type_name => typ = Some(inner.as_str().trim().to_string()),
-                        _ => {}
-                    }
-                }
-            }
+            Rule::using_attribute => return Err(ClassError::UnexpectedUsingAttribute),
             Rule::named_attribute => {
                 for inner in p.into_inner() {
                     match inner.as_rule() {
@@ -145,7 +202,59 @@ fn parse_attribute(pair: pest::iterators::Pair<Rule>) -> Attribute {
     attr.visibility = parse_visibility(vis);
     attr.name = name.unwrap_or_default();
     attr.r#type = typ;
-    attr
+    Ok(attr)
+}
+
+fn parse_type_alias(pair: pest::iterators::Pair<Rule>) -> TypeAlias {
+    let mut alias = None;
+    let mut original_type = None;
+
+    for p in pair.into_inner() {
+        if p.as_rule() != Rule::using_attribute {
+            continue;
+        }
+
+        for inner in p.into_inner() {
+            match inner.as_rule() {
+                Rule::identifier => alias = Some(inner.as_str().to_string()),
+                Rule::type_name => original_type = Some(inner.as_str().trim().to_string()),
+                _ => {}
+            }
+        }
+    }
+
+    TypeAlias {
+        alias: alias.unwrap_or_default(),
+        original_type: original_type.unwrap_or_default(),
+    }
+}
+
+enum ParsedClassMember {
+    Attribute(Attribute),
+    TypeAlias(TypeAlias),
+    Method(Method),
+}
+
+fn parse_class_member(pair: pest::iterators::Pair<Rule>) -> Result<ParsedClassMember, ClassError> {
+    match pair.as_rule() {
+        Rule::attribute => {
+            let is_type_alias = pair
+                .clone()
+                .into_inner()
+                .any(|inner| inner.as_rule() == Rule::using_attribute);
+
+            if is_type_alias {
+                Ok(ParsedClassMember::TypeAlias(parse_type_alias(pair)))
+            } else {
+                Ok(ParsedClassMember::Attribute(parse_attribute(pair)?))
+            }
+        }
+        Rule::method => Ok(ParsedClassMember::Method(parse_method(pair))),
+        _ => Err(ClassError::UnexpectedClassMember(format!(
+            "{:?}",
+            pair.as_rule()
+        ))),
+    }
 }
 
 fn parse_param(pair: pest::iterators::Pair<Rule>) -> Param {
@@ -192,7 +301,7 @@ fn parse_param(pair: pest::iterators::Pair<Rule>) -> Param {
     let mut ty: Option<String> = None;
     let mut varargs = false;
 
-    // param -> param_named | param_unnamed
+    // param -> param_named | param_cpp_named | param_unnamed
     let inner = pair.into_inner().next().unwrap();
 
     match inner.as_rule() {
@@ -213,6 +322,23 @@ fn parse_param(pair: pest::iterators::Pair<Rule>) -> Param {
             }
         }
 
+        Rule::param_cpp_named => {
+            for p in inner.into_inner() {
+                match p.as_rule() {
+                    Rule::type_name => {
+                        ty = Some(p.as_str().trim().to_string());
+                    }
+                    Rule::identifier => {
+                        name = Some(p.as_str().to_string());
+                    }
+                    Rule::varargs => {
+                        varargs = true;
+                    }
+                    _ => {}
+                }
+            }
+        }
+
         Rule::param_unnamed => {
             for p in inner.into_inner() {
                 match p.as_rule() {
@@ -251,15 +377,27 @@ fn parse_method(pair: pest::iterators::Pair<Rule>) -> Method {
             .collect()
     }
 
+    fn ensure_abstract_modifier(method: &mut Method) {
+        if !method
+            .modifiers
+            .iter()
+            .any(|modifier| modifier == "{abstract}")
+        {
+            method.modifiers.push("{abstract}".to_string());
+        }
+    }
+
     let mut method = Method::default();
     let mut vis = None;
     let mut name = None;
 
     for p in pair.into_inner() {
         match p.as_rule() {
-            Rule::static_modifier | Rule::abstract_modifier | Rule::const_method_suffix => {
-                method.modifiers.push(p.as_str().to_string())
-            }
+            Rule::static_modifier
+            | Rule::abstract_modifier
+            | Rule::const_method_qualifier
+            | Rule::noexcept_method_qualifier => method.modifiers.push(p.as_str().to_string()),
+            Rule::pure_virtual_suffix => ensure_abstract_modifier(&mut method),
             Rule::class_visibility => vis = Some(p),
             Rule::method_name | Rule::identifier => name = Some(p.as_str().to_string()),
             Rule::param_list => {
@@ -272,13 +410,21 @@ fn parse_method(pair: pest::iterators::Pair<Rule>) -> Method {
             }
             Rule::return_type => {
                 for return_type_inner in p.into_inner() {
-                    if return_type_inner.as_rule() == Rule::type_name {
-                        method.r#type = Some(return_type_inner.as_str().trim().to_string());
+                    match return_type_inner.as_rule() {
+                        Rule::static_modifier => {
+                            method
+                                .modifiers
+                                .push(return_type_inner.as_str().to_string());
+                        }
+                        Rule::type_name => {
+                            method.r#type = Some(return_type_inner.as_str().trim().to_string());
+                        }
+                        _ => {}
                     }
                 }
             }
             Rule::generic_param_list => {
-                method.generic_params.extend(parse_generic_param_list(p));
+                method.template_parameters = Some(parse_generic_param_list(p));
             }
             _ => (),
         }
@@ -289,13 +435,15 @@ fn parse_method(pair: pest::iterators::Pair<Rule>) -> Method {
     method
 }
 
-fn parse_type_def_into<T>(pair: pest::iterators::Pair<Rule>) -> T
+fn parse_type_def_into<T>(pair: pest::iterators::Pair<Rule>) -> Result<T, ClassError>
 where
     T: TypeDef + Default,
 {
+    let source_line = pair.as_span().start_pos().line_col().0 as u32;
     let mut def = T::default();
+    *def.source_line_mut() = Some(source_line);
 
-    fn walk<T>(pair: pest::iterators::Pair<Rule>, def: &mut T)
+    fn walk<T>(pair: pest::iterators::Pair<Rule>, def: &mut T) -> Result<(), ClassError>
     where
         T: TypeDef,
     {
@@ -307,12 +455,14 @@ where
                 for inner in pair.into_inner() {
                     if let Rule::class_member = inner.as_rule() {
                         for member in inner.into_inner() {
-                            match member.as_rule() {
-                                Rule::attribute => {
-                                    def.attributes_mut().push(parse_attribute(member))
+                            match parse_class_member(member)? {
+                                ParsedClassMember::Attribute(attribute) => {
+                                    def.attributes_mut().push(attribute)
                                 }
-                                Rule::method => def.methods_mut().push(parse_method(member)),
-                                _ => (),
+                                ParsedClassMember::TypeAlias(type_alias) => {
+                                    def.type_aliases_mut().push(type_alias)
+                                }
+                                ParsedClassMember::Method(method) => def.methods_mut().push(method),
                             }
                         }
                     }
@@ -320,18 +470,59 @@ where
             }
             _ => {
                 for inner in pair.into_inner() {
-                    walk(inner, def);
+                    walk(inner, def)?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    walk(pair, &mut def)?;
+
+    Ok(def)
+}
+
+fn parse_ignored_object_name(pair: pest::iterators::Pair<Rule>) -> Name {
+    fn walk(pair: pest::iterators::Pair<Rule>, name: &mut Name) {
+        match pair.as_rule() {
+            Rule::named => parse_named(pair, name),
+            _ => {
+                for inner in pair.into_inner() {
+                    walk(inner, name);
                 }
             }
         }
     }
 
-    walk(pair, &mut def);
+    let mut name = Name::default();
+    walk(pair, &mut name);
+    name
+}
 
-    def
+fn filter_relationships(
+    relationships: Vec<Relationship>,
+    ignored_objects: &IgnoredObjectRegistry,
+    parent: &Option<String>,
+) -> Vec<Relationship> {
+    relationships
+        .into_iter()
+        .filter(|relationship| !ignored_objects.filters_relationship(relationship, parent))
+        .collect()
 }
 
-fn parse_type_def(pair: pest::iterators::Pair<Rule>) -> Element {
+fn original_start_line(
+    pair: &pest::iterators::Pair<Rule>,
+    normalized_content: &NormalizedContent,
+) -> u32 {
+    let (line, column) = pair.as_span().start_pos().line_col();
+    normalized_content.map_position(line, column).0 as u32
+}
+
+fn parse_type_def(
+    pair: pest::iterators::Pair<Rule>,
+    normalized_content: &NormalizedContent,
+) -> Result<Element, ClassError> {
     debug_assert_eq!(pair.as_rule(), Rule::type_def);
 
     fn find_type_kind(pair: pest::iterators::Pair<Rule>) -> Option<String> {
@@ -400,14 +591,15 @@ fn parse_type_def(pair: pest::iterators::Pair<Rule>) -> Element {
         targets
     }
 
-    fn collect_type_template_params(pair: pest::iterators::Pair<Rule>) -> Vec<String> {
-        fn walk(pair: pest::iterators::Pair<Rule>, params: &mut Vec<String>) {
+    fn collect_type_template_parameters(pair: pest::iterators::Pair<Rule>) -> Option<Vec<String>> {
+        fn walk(pair: pest::iterators::Pair<Rule>, params: &mut Option<Vec<String>>) {
             match pair.as_rule() {
                 Rule::type_generic_param_list => {
-                    params.extend(
+                    *params = Some(
                         pair.into_inner()
                             .filter(|inner| inner.as_rule() == Rule::template_param)
-                            .map(|inner| inner.as_str().to_string()),
+                            .map(|inner| inner.as_str().to_string())
+                            .collect(),
                     );
                 }
                 Rule::class_body => {}
@@ -419,12 +611,20 @@ fn parse_type_def(pair: pest::iterators::Pair<Rule>) -> Element {
             }
         }
 
-        let mut params = Vec::new();
+        let mut params = None;
         walk(pair, &mut params);
         params
     }
 
-    fn parse_template_param_list_text(text: &str) -> Vec<String> {
+    fn parse_template_parameter_list_text(text: &str) -> Option<Vec<String>> {
+        let trimmed = text.trim();
+        if trimmed.starts_with('<') && trimmed.ends_with('>') {
+            let inner = trimmed[1..trimmed.len() - 1].trim();
+            if inner.is_empty() {
+                return Some(vec![]);
+            }
+        }
+
         PlantUmlCommonParser::parse(Rule::type_generic_param_list, text)
             .ok()
             .and_then(|mut pairs| pairs.next())
@@ -434,12 +634,11 @@ fn parse_type_def(pair: pest::iterators::Pair<Rule>) -> Element {
                     .map(|inner| inner.as_str().to_string())
                     .collect()
             })
-            .unwrap_or_default()
     }
 
-    fn infer_template_params_from_template_string(name: &str) -> Vec<String> {
+    fn infer_template_parameters_from_template_string(name: &str) -> Option<Vec<String>> {
         if !name.contains("<<template>>") {
-            return Vec::new();
+            return None;
         }
 
         let candidate = name
@@ -452,66 +651,107 @@ fn parse_type_def(pair: pest::iterators::Pair<Rule>) -> Element {
             .trim();
 
         let Some(start) = candidate.find('<') else {
-            return Vec::new();
+            return None;
         };
         let Some(end) = candidate.rfind('>') else {
-            return Vec::new();
+            return None;
         };
 
         if end <= start {
-            return Vec::new();
+            return None;
         }
 
-        parse_template_param_list_text(&candidate[start..=end])
+        parse_template_parameter_list_text(&candidate[start..=end])
     }
 
-    fn resolve_type_template_params(explicit: Vec<String>, internal_name: &str) -> Vec<String> {
-        if !explicit.is_empty() {
-            explicit
-        } else {
-            infer_template_params_from_template_string(internal_name)
-        }
+    fn infer_template_parameters_from_type_def_text(raw_type_def: &str) -> Option<Vec<String>> {
+        let marker_index = raw_type_def.find("<<template>>")?;
+        let template_label = raw_type_def[marker_index..]
+            .split('"')
+            .next()
+            .unwrap_or_default();
+
+        infer_template_parameters_from_template_string(template_label)
     }
 
+    fn resolve_type_template_parameters(
+        explicit: Option<Vec<String>>,
+        name: &Name,
+        raw_type_def: &str,
+    ) -> Option<Vec<String>> {
+        explicit.or_else(|| {
+            name.display
+                .as_deref()
+                .and_then(infer_template_parameters_from_template_string)
+                .or_else(|| infer_template_parameters_from_template_string(&name.internal))
+                .or_else(|| infer_template_parameters_from_type_def_text(raw_type_def))
+        })
+    }
+
+    let raw_type_def = pair.as_str().to_string();
+    let source_line = original_start_line(&pair, normalized_content);
     let kind = find_type_kind(pair.clone()).expect("type_def must have type_kind");
-    let explicit_template_params = collect_type_template_params(pair.clone());
+    let explicit_template_parameters = collect_type_template_parameters(pair.clone());
     let extends_targets = collect_extends_targets(pair.clone());
     let implements_targets = collect_implements_targets(pair.clone());
 
     match kind.as_str() {
+        "abstract class" => {
+            let mut def = parse_type_def_into::<ClassDef>(pair)?;
+            def.source_line = Some(source_line);
+            def.is_abstract = true;
+            def.template_parameters = resolve_type_template_parameters(
+                explicit_template_parameters,
+                &def.name,
+                &raw_type_def,
+            );
+            def.extends = extends_targets;
+            def.implements = implements_targets;
+            Ok(Element::ClassDef(def))
+        }
         "class" => {
-            let mut def = parse_type_def_into::<ClassDef>(pair);
-            def.template_params =
-                resolve_type_template_params(explicit_template_params, &def.name.internal);
+            let mut def = parse_type_def_into::<ClassDef>(pair)?;
+            def.source_line = Some(source_line);
+            def.template_parameters = resolve_type_template_parameters(
+                explicit_template_parameters,
+                &def.name,
+                &raw_type_def,
+            );
             def.extends = extends_targets;
             def.implements = implements_targets;
-            Element::ClassDef(def)
+            Ok(Element::ClassDef(def))
         }
         "struct" => {
-            let mut def = parse_type_def_into::<StructDef>(pair);
-            def.template_params =
-                resolve_type_template_params(explicit_template_params, &def.name.internal);
-            Element::StructDef(def)
+            let mut def = parse_type_def_into::<StructDef>(pair)?;
+            def.source_line = Some(source_line);
+            def.template_parameters = resolve_type_template_parameters(
+                explicit_template_parameters,
+                &def.name,
+                &raw_type_def,
+            );
+            Ok(Element::StructDef(def))
         }
         "interface" => {
-            let mut def = parse_type_def_into::<InterfaceDef>(pair);
-            def.template_params =
-                resolve_type_template_params(explicit_template_params, &def.name.internal);
+            let mut def = parse_type_def_into::<InterfaceDef>(pair)?;
+            def.source_line = Some(source_line);
+            def.template_parameters = resolve_type_template_parameters(
+                explicit_template_parameters,
+                &def.name,
+                &raw_type_def,
+            );
             def.extends = extends_targets;
-            Element::InterfaceDef(def)
-        }
-        "object" => {
-            let mut def = parse_type_def_into::<ObjectDef>(pair);
-            def.template_params =
-                resolve_type_template_params(explicit_template_params, &def.name.internal);
-            Element::ObjectDef(def)
+            Ok(Element::InterfaceDef(def))
         }
         _ => unreachable!("unknown type_kind: {}", kind),
     }
 }
 
-fn parse_enum_def(pair: pest::iterators::Pair<Rule>) -> EnumDef {
+fn parse_enum_def(
+    pair: pest::iterators::Pair<Rule>,
+    normalized_content: &NormalizedContent,
+) -> EnumDef {
     let mut enum_def = EnumDef::default();
+    enum_def.source_line = Some(original_start_line(&pair, normalized_content));
 
     for inner in pair.into_inner() {
         match inner.as_rule() {
@@ -541,9 +781,6 @@ fn parse_enum_item(pair: pest::iterators::Pair<Rule>) -> EnumItem {
 
     for inner in pair.into_inner() {
         match inner.as_rule() {
-            Rule::class_visibility => {
-                item.visibility = Some(parse_visibility(Some(inner)));
-            }
             Rule::identifier => {
                 item.name = inner.as_str().to_string();
             }
@@ -583,8 +820,12 @@ where
     }
 }
 
-fn parse_namespace(pair: pest::iterators::Pair<Rule>) -> Namespace {
+fn parse_namespace(
+    pair: pest::iterators::Pair<Rule>,
+    normalized_content: &NormalizedContent,
+) -> Result<(Namespace, IgnoredObjectRegistry), ClassError> {
     let mut namespace = Namespace::default();
+    let mut ignored_objects = IgnoredObjectRegistry::default();
 
     for inner in pair.into_inner() {
         match inner.as_rule() {
@@ -592,35 +833,67 @@ fn parse_namespace(pair: pest::iterators::Pair<Rule>) -> Namespace {
                 parse_named(inner, &mut namespace.name);
             }
             Rule::top_level => {
-                visit_top_level(
-                    inner,
-                    &mut |top_level_inner| match top_level_inner.as_rule() {
+                let mut visit_result = Ok(());
+                visit_top_level(inner, &mut |top_level_inner| {
+                    if visit_result.is_err() {
+                        return;
+                    }
+
+                    visit_result = match top_level_inner.as_rule() {
                         Rule::type_def => {
-                            let mut type_def = parse_type_def(top_level_inner);
+                            let mut type_def =
+                                match parse_type_def(top_level_inner, normalized_content) {
+                                    Ok(type_def) => type_def,
+                                    Err(error) => return visit_result = Err(error),
+                                };
                             type_def.set_namespace(namespace.name.internal.clone());
                             namespace.types.push(type_def);
+                            Ok(())
+                        }
+                        Rule::unsupported_object_def => {
+                            let ignored = parse_ignored_object_name(top_level_inner);
+                            ignored_objects
+                                .register(&ignored, &Some(namespace.name.internal.clone()));
+                            Ok(())
                         }
                         Rule::enum_def => {
-                            let mut enum_def = Element::EnumDef(parse_enum_def(top_level_inner));
+                            let mut enum_def = Element::EnumDef(parse_enum_def(
+                                top_level_inner,
+                                normalized_content,
+                            ));
                             enum_def.set_namespace(namespace.name.internal.clone());
                             namespace.types.push(enum_def);
+                            Ok(())
                         }
                         Rule::namespace_def => {
-                            namespace.namespaces.push(parse_namespace(top_level_inner));
+                            let (nested_namespace, nested_ignored_objects) =
+                                match parse_namespace(top_level_inner, normalized_content) {
+                                    Ok(parsed) => parsed,
+                                    Err(error) => return visit_result = Err(error),
+                                };
+                            ignored_objects.merge(nested_ignored_objects);
+                            namespace.namespaces.push(nested_namespace);
+                            Ok(())
                         }
-                        _ => (),
-                    },
-                );
+                        _ => Ok(()),
+                    };
+                });
+                visit_result?;
             }
             _ => (),
         }
     }
 
-    namespace
+    Ok((namespace, ignored_objects))
 }
 
-fn parse_package(pair: pest::iterators::Pair<Rule>) -> Package {
+fn parse_package(
+    pair: pest::iterators::Pair<Rule>,
+    normalized_content: &NormalizedContent,
+) -> Result<(Package, IgnoredObjectRegistry), ClassError> {
     let mut package = Package::default();
+    let mut ignored_objects = IgnoredObjectRegistry::default();
+    let mut relationships = Vec::new();
 
     for inner in pair.into_inner() {
         match inner.as_rule() {
@@ -629,46 +902,107 @@ fn parse_package(pair: pest::iterators::Pair<Rule>) -> Package {
             }
 
             Rule::top_level => {
-                visit_top_level(inner, &mut |t| match t.as_rule() {
-                    Rule::type_def => {
-                        let mut r#type = parse_type_def(t);
-                        r#type.set_package(package.name.internal.clone());
-                        package.types.push(r#type);
-                    }
-                    Rule::enum_def => {
-                        let mut enum_def = Element::EnumDef(parse_enum_def(t));
-                        enum_def.set_package(package.name.internal.clone());
-                        package.types.push(enum_def);
+                let mut visit_result = Ok(());
+                visit_top_level(inner, &mut |t| {
+                    if visit_result.is_err() {
+                        return;
                     }
-                    Rule::relationship => {
-                        package.relationships.push(parse_relationship(t));
-                    }
-                    Rule::package_def => {
-                        package.packages.push(parse_package(t));
-                    }
-                    _ => {}
+
+                    visit_result = match t.as_rule() {
+                        Rule::type_def => {
+                            let mut r#type = match parse_type_def(t, normalized_content) {
+                                Ok(r#type) => r#type,
+                                Err(error) => return visit_result = Err(error),
+                            };
+                            r#type.set_package(package.name.internal.clone());
+                            package.types.push(r#type);
+                            Ok(())
+                        }
+                        Rule::unsupported_object_def => {
+                            let ignored = parse_ignored_object_name(t);
+                            ignored_objects
+                                .register(&ignored, &Some(package.name.internal.clone()));
+                            Ok(())
+                        }
+                        Rule::enum_def => {
+                            let mut enum_def =
+                                Element::EnumDef(parse_enum_def(t, normalized_content));
+                            enum_def.set_package(package.name.internal.clone());
+                            package.types.push(enum_def);
+                            Ok(())
+                        }
+                        Rule::relationship => {
+                            relationships.push(parse_relationship(t));
+                            Ok(())
+                        }
+                        Rule::package_def => {
+                            let (subpackage, nested_ignored_objects) =
+                                match parse_package(t, normalized_content) {
+                                    Ok(parsed) => parsed,
+                                    Err(error) => return visit_result = Err(error),
+                                };
+                            ignored_objects.merge(nested_ignored_objects);
+                            package.packages.push(subpackage);
+                            Ok(())
+                        }
+                        _ => Ok(()),
+                    };
                 });
+                visit_result?;
             }
             _ => {}
         }
     }
 
-    package
+    package.relationships = filter_relationships(
+        relationships,
+        &ignored_objects,
+        &Some(package.name.internal.clone()),
+    );
+
+    Ok((package, ignored_objects))
 }
 
 fn parse_label(pair: pest::iterators::Pair<Rule>) -> String {
     pair.as_str().trim().to_string()
 }
 
+fn strip_wrapping_quotes(text: &str) -> String {
+    if text.starts_with('"') && text.ends_with('"') && text.len() >= 2 {
+        text[1..text.len() - 1].to_string()
+    } else {
+        text.to_string()
+    }
+}
+
 fn parse_relationship(pair: pest::iterators::Pair<Rule>) -> Relationship {
     let mut inner = pair.into_inner();
 
     let left = inner.next().unwrap().as_str().trim().to_string();
 
-    let arrow_pair = inner.next().unwrap();
+    let next = inner.next().unwrap();
+    let (left_multiplicity, arrow_pair) = if next.as_rule() == Rule::relationship_multiplicity {
+        (
+            Some(strip_wrapping_quotes(next.as_str().trim())),
+            inner.next().unwrap(),
+        )
+    } else {
+        (None, next)
+    };
+
     let arrow = parse_arrow(arrow_pair).unwrap_or_else(|_| Arrow::default());
 
-    let right = inner.next().unwrap().as_str().trim().to_string();
+    let next = inner.next().unwrap();
+    let (right_multiplicity, right_pair) = if next.as_rule() == Rule::relationship_multiplicity {
+        (
+            Some(strip_wrapping_quotes(next.as_str().trim())),
+            inner.next().unwrap(),
+        )
+    } else {
+        (None, next)
+    };
+
+    let right = right_pair.as_str().trim().to_string();
 
     let mut label: Option<String> = None;
     for p in inner {
@@ -681,6 +1015,8 @@ fn parse_relationship(pair: pest::iterators::Pair<Rule>) -> Relationship {
         left,
         right,
         arrow,
+        left_multiplicity,
+        right_multiplicity,
         label,
     }
 }
@@ -711,6 +1047,8 @@ impl DiagramParser for PumlClassParser {
         }
 
         let mut uml_file = ClassUmlFile::default();
+        let mut ignored_objects = IgnoredObjectRegistry::default();
+        let mut relationships = Vec::new();
 
         match PlantUmlCommonParser::parse(Rule::class_start, normalized_content.as_str()) {
             Ok(mut pairs) => {
@@ -721,31 +1059,63 @@ impl DiagramParser for PumlClassParser {
                 for pair in inner {
                     match pair.as_rule() {
                         Rule::top_level => {
-                            visit_top_level(pair, &mut |inner_pair| match inner_pair.as_rule() {
-                                Rule::type_def => {
-                                    let type_def = parse_type_def(inner_pair);
-                                    uml_file.elements.push(ClassUmlTopLevel::Types(type_def));
-                                }
-                                Rule::enum_def => {
-                                    uml_file
-                                        .elements
-                                        .push(ClassUmlTopLevel::Enum(parse_enum_def(inner_pair)));
-                                }
-                                Rule::namespace_def => {
-                                    uml_file.elements.push(ClassUmlTopLevel::Namespace(
-                                        parse_namespace(inner_pair),
-                                    ));
+                            let mut visit_result = Ok(());
+                            visit_top_level(pair, &mut |inner_pair| {
+                                if visit_result.is_err() {
+                                    return;
                                 }
-                                Rule::relationship => {
-                                    uml_file.relationships.push(parse_relationship(inner_pair));
-                                }
-                                Rule::package_def => {
-                                    uml_file
-                                        .elements
-                                        .push(ClassUmlTopLevel::Package(parse_package(inner_pair)));
-                                }
-                                _ => (),
+
+                                visit_result = match inner_pair.as_rule() {
+                                    Rule::type_def => {
+                                        let type_def =
+                                            match parse_type_def(inner_pair, &normalized_content) {
+                                                Ok(type_def) => type_def,
+                                                Err(error) => return visit_result = Err(error),
+                                            };
+                                        uml_file.elements.push(ClassUmlTopLevel::Types(type_def));
+                                        Ok(())
+                                    }
+                                    Rule::unsupported_object_def => {
+                                        let ignored = parse_ignored_object_name(inner_pair);
+                                        ignored_objects.register(&ignored, &None);
+                                        Ok(())
+                                    }
+                                    Rule::enum_def => {
+                                        uml_file.elements.push(ClassUmlTopLevel::Enum(
+                                            parse_enum_def(inner_pair, &normalized_content),
+                                        ));
+                                        Ok(())
+                                    }
+                                    Rule::namespace_def => {
+                                        let (namespace, nested_ignored_objects) =
+                                            match parse_namespace(inner_pair, &normalized_content) {
+                                                Ok(parsed) => parsed,
+                                                Err(error) => return visit_result = Err(error),
+                                            };
+                                        ignored_objects.merge(nested_ignored_objects);
+                                        uml_file
+                                            .elements
+                                            .push(ClassUmlTopLevel::Namespace(namespace));
+                                        Ok(())
+                                    }
+                                    Rule::relationship => {
+                                        relationships.push(parse_relationship(inner_pair));
+                                        Ok(())
+                                    }
+                                    Rule::package_def => {
+                                        let (package, nested_ignored_objects) =
+                                            match parse_package(inner_pair, &normalized_content) {
+                                                Ok(parsed) => parsed,
+                                                Err(error) => return visit_result = Err(error),
+                                            };
+                                        ignored_objects.merge(nested_ignored_objects);
+                                        uml_file.elements.push(ClassUmlTopLevel::Package(package));
+                                        Ok(())
+                                    }
+                                    _ => Ok(()),
+                                };
                             });
+                            visit_result?;
                         }
                         Rule::startuml => {
                             let text = pair.as_str();
@@ -766,6 +1136,8 @@ impl DiagramParser for PumlClassParser {
             }
         };
 
+        uml_file.relationships = filter_relationships(relationships, &ignored_objects, &None);
+
         Ok(uml_file)
     }
 }
@@ -912,6 +1284,8 @@ mod tests {
 
         assert_eq!(rel.left, "A");
         assert_eq!(rel.right, "B");
+        assert_eq!(rel.left_multiplicity, None);
+        assert_eq!(rel.right_multiplicity, None);
     }
 
     #[test]
diff --git a/plantuml/parser/puml_parser/src/class_diagram/src/class_traits.rs b/plantuml/parser/puml_parser/src/class_diagram/src/class_traits.rs
index aea9b478..86bd2a38 100644
--- a/plantuml/parser/puml_parser/src/class_diagram/src/class_traits.rs
+++ b/plantuml/parser/puml_parser/src/class_diagram/src/class_traits.rs
@@ -10,12 +10,14 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 // *******************************************************************************
-use crate::class_ast::{Attribute, Method, Name};
+use crate::class_ast::{Attribute, Method, Name, TypeAlias};
 
 pub trait TypeDef {
     fn name_mut(&mut self) -> &mut Name;
     fn attributes_mut(&mut self) -> &mut Vec<Attribute>;
+    fn type_aliases_mut(&mut self) -> &mut Vec<TypeAlias>;
     fn methods_mut(&mut self) -> &mut Vec<Method>;
+    fn source_line_mut(&mut self) -> &mut Option<u32>;
 }
 
 pub trait WritableName {
diff --git a/plantuml/parser/puml_parser/src/class_diagram/src/lib.rs b/plantuml/parser/puml_parser/src/class_diagram/src/lib.rs
index d75c241a..f2faeb0d 100644
--- a/plantuml/parser/puml_parser/src/class_diagram/src/lib.rs
+++ b/plantuml/parser/puml_parser/src/class_diagram/src/lib.rs
@@ -17,7 +17,7 @@ mod source_map;
 
 pub use class_ast::{
     Attribute, ClassDef, ClassUmlFile, ClassUmlTopLevel, Element, EnumDef, EnumItem, EnumValue,
-    InterfaceDef, Method, Name, Namespace, ObjectDef, Package, Param, Relationship, StructDef,
+    InterfaceDef, Method, Name, Namespace, Package, Param, Relationship, StructDef, TypeAlias,
     Visibility,
 };
 pub use class_parser::{ClassError, PumlClassParser};
diff --git a/plantuml/parser/puml_parser/src/grammar/class.pest b/plantuml/parser/puml_parser/src/grammar/class.pest
index 91a37a02..8b7e6c59 100644
--- a/plantuml/parser/puml_parser/src/grammar/class.pest
+++ b/plantuml/parser/puml_parser/src/grammar/class.pest
@@ -77,6 +77,7 @@ class_start = {
 top_level = {
       namespace_def
     | type_def
+    | unsupported_object_def
     | enum_def
     | package_def
     | together_def
@@ -137,8 +138,10 @@ package_def = {
 // type definition
 ///////////////////////////////////////////////////////////////
 type_def = { type_def_with_body | type_def_decl }
+unsupported_object_def = { object_def_with_body | object_def_decl }
 
 type_def_decl = { type_kind ~ named ~ type_decl_suffix* }
+object_def_decl = { "object" ~ named ~ type_decl_suffix* }
 type_decl_suffix = _{ extends_clause | implements_clause | link_annotation | stereotype | color }
 template_param = @{ identifier ~ varargs? }
 template_param_list = _{ "<" ~ template_param ~ ("," ~ template_param)* ~ ">" }
@@ -149,12 +152,13 @@ extends_target = { class_qualified_name }
 implements_clause = { "implements" ~ implements_target ~ ("," ~ implements_target)* }
 implements_target = { class_qualified_name }
 
-type_def_with_body = { type_def_decl ~ &(EOL* ~ "{") ~ EOL* ~ class_body }
+type_def_with_body = { type_def_decl ~ &(EOL* ~ "{") ~ EOL* ~ class_body ~ ";"? }
+object_def_with_body = { object_def_decl ~ &(EOL* ~ "{") ~ EOL* ~ class_body ~ ";"? }
 type_kind = {
-      "class"
+      "abstract" ~ "class"
+    | "class"
     | "struct"
     | "interface"
-    | "object"
 }
 
 class_body = { "{" ~ EOL* ~ (class_member | class_body_separator)* ~ EOL* ~ "}" }
@@ -173,13 +177,21 @@ method = {
     ~ EOL*
     ~ ")"
     ~ generic_param_list?
+    ~ method_qualifier*
     ~ return_type?
-    ~ const_method_suffix?
+    ~ method_qualifier*
+    ~ pure_virtual_suffix?
+    ~ ";"?
 }
 method_modifier = _{ static_modifier | abstract_modifier }
-static_modifier = { "{" ~ "static" ~ "}" }
+static_modifier = { "{" ~ static_keyword ~ "}" | static_keyword }
+static_keyword = { "static" }
 abstract_modifier = { "{" ~ "abstract" ~ "}" }
-const_method_suffix = { "<<" ~ "const" ~ ">>" }
+method_qualifier = _{ const_method_qualifier | noexcept_method_qualifier }
+const_method_qualifier = { ("<<" ~ "const" ~ ">>") | "const" }
+noexcept_method_qualifier = { "noexcept" }
+pure_virtual_suffix = { "=" ~ "0" }
+
 method_name = { operator_overload_name | destructor_name | identifier }
 destructor_name = @{ "~" ~ identifier }
 operator_overload_name = @{
@@ -224,16 +236,17 @@ operator_overload_name = @{
             | ","
         )
 }
-return_type = { ":" ~ type_name }
+return_type = { ":" ~ static_modifier* ~ type_name }
 
 attribute = { static_modifier* ~ class_visibility? ~ (using_attribute | named_attribute | unnamed_attribute) }
-attribute_end = _{ &(WHITESPACE* ~ (EOL | "}")) }
+attribute_end = _{ ";"? ~ &(WHITESPACE* ~ (EOL | "}")) }
 using_attribute = { "using" ~ identifier ~ "=" ~ type_name ~ attribute_end }
 named_attribute = { identifier ~ (":" ~ type_name)? ~ attribute_end }
 unnamed_attribute = { type_name ~ attribute_end }
 
 param = {
     param_named
+  | param_cpp_named
   | param_unnamed
 }
 
@@ -241,13 +254,23 @@ param_named = {
     identifier
     ~ ":"
     ~ type_name
+    ~ param_default_value?
+    ~ varargs?
+}
+
+param_cpp_named = {
+    type_name
+    ~ identifier
+    ~ param_default_value?
     ~ varargs?
 }
 
 param_unnamed = {
     type_name
+    ~ param_default_value?
     ~ varargs?
 }
+param_default_value = { "=" ~ (!("," | ")" | EOL) ~ ANY)* }
 param_list  = { param ~ (EOL* ~ "," ~ EOL* ~ param)* }
 
 generic_param_list = { template_param_list }
@@ -256,11 +279,11 @@ varargs = { "..." }
 ///////////////////////////////////////////////////////////////
 // type definition
 ///////////////////////////////////////////////////////////////
-enum_def = { "enum" ~ named ~ stereotype? ~ enum_body?}
+enum_def = { "enum" ~ named ~ stereotype? ~ enum_body? ~ ";"? }
 
 enum_body = { "{" ~ EOL* ~ enum_item* ~ EOL* ~ "}" }
 
-enum_item = { class_visibility? ~ identifier ~ enum_value? ~ EOL+ }
+enum_item = { identifier ~ enum_value? ~ EOL+ }
 
 enum_value = { ( "=" | ":" ) ~ enum_value_literal }
 
@@ -271,10 +294,13 @@ enum_value_literal = @{ (!("\n" | "}") ~ ANY)+ }
 ///////////////////////////////////////////////////////////////
 
 qualified_identifier = @{ name_ref ~ ("." ~ name_ref)+ }
+relationship_multiplicity = { STRING }
 
 relationship = {
     (qualified_identifier | name_ref)
+    ~ relationship_multiplicity?
     ~ connection_arrow
+    ~ relationship_multiplicity?
     ~ (qualified_identifier | name_ref)
     ~ (":" ~ label)?
 }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/alias_class/output.json b/plantuml/parser/puml_parser/tests/class_diagram/alias_class/output.json
index 822113b6..ff65805a 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/alias_class/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/alias_class/output.json
@@ -11,8 +11,14 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [],
-            "methods": []
+            "methods": [],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       },
@@ -25,8 +31,11 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 16,
+            "type_aliases": [],
             "attributes": [],
-            "methods": []
+            "methods": [],
+            "template_parameters": null
           }
         }
       },
@@ -38,6 +47,7 @@
           },
           "namespace": "",
           "package": "",
+          "source_line": 17,
           "stereotypes": [],
           "items": []
         }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/alias_package/output.json b/plantuml/parser/puml_parser/tests/class_diagram/alias_package/output.json
index 240c967c..cbc3ff21 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/alias_package/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/alias_package/output.json
@@ -1,5 +1,5 @@
-{"alias_package.puml":
-  {
+{
+  "alias_package.puml": {
     "name": "alias_package",
     "elements": [
       {
@@ -11,8 +11,11 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "type_aliases": [],
             "attributes": [],
-            "methods": []
+            "methods": [],
+            "template_parameters": null
           }
         }
       },
@@ -31,8 +34,14 @@
                 },
                 "namespace": "",
                 "package": "diag",
+                "source_line": 18,
+                "is_abstract": false,
+                "type_aliases": [],
                 "attributes": [],
-                "methods": []
+                "methods": [],
+                "template_parameters": null,
+                "extends": [],
+                "implements": []
               }
             },
             {
@@ -43,8 +52,14 @@
                 },
                 "namespace": "",
                 "package": "diag",
+                "source_line": 19,
+                "is_abstract": false,
+                "type_aliases": [],
                 "attributes": [],
-                "methods": []
+                "methods": [],
+                "template_parameters": null,
+                "extends": [],
+                "implements": []
               }
             }
           ],
@@ -67,8 +82,11 @@
                 },
                 "namespace": "",
                 "package": "activate",
+                "source_line": 23,
+                "type_aliases": [],
                 "attributes": [],
-                "methods": []
+                "methods": [],
+                "template_parameters": null
               }
             },
             {
@@ -79,6 +97,7 @@
                 },
                 "namespace": "",
                 "package": "activate",
+                "source_line": 24,
                 "stereotypes": [],
                 "items": []
               }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/attr_method/output.json b/plantuml/parser/puml_parser/tests/class_diagram/attr_method/output.json
index 593a4fcf..3a007389 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/attr_method/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/attr_method/output.json
@@ -1,5 +1,5 @@
-{"attr_method.puml":
-  {
+{
+  "attr_method.puml": {
     "name": "attr_method",
     "elements": [
       {
@@ -11,27 +11,36 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [
               {
                 "visibility": "Public",
                 "name": "name",
-                "type": "string"
+                "type": "string",
+                "modifiers": []
               },
               {
                 "visibility": "Private",
                 "name": "id",
-                "type": "int"
+                "type": "int",
+                "modifiers": []
               }
             ],
             "methods": [
               {
                 "visibility": "Public",
                 "name": "getName",
-                "generic_params": [],
                 "params": [],
-                "type": "string"
+                "type": "string",
+                "template_parameters": null,
+                "modifiers": []
               }
-            ]
+            ],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/class_merge/output.json b/plantuml/parser/puml_parser/tests/class_diagram/class_merge/output.json
index cb68a5d1..b97a6c8b 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/class_merge/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/class_merge/output.json
@@ -1,5 +1,5 @@
-{"class_merge.puml":
-  {
+{
+  "class_merge.puml": {
     "name": "class_merge",
     "elements": [
       {
@@ -11,14 +11,21 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [
               {
                 "visibility": "Public",
                 "name": "attr_1",
-                "type": "int"
+                "type": "int",
+                "modifiers": []
               }
             ],
-            "methods": []
+            "methods": [],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       },
@@ -31,14 +38,21 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 19,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [
               {
                 "visibility": "Private",
                 "name": "attr_2",
-                "type": "int"
+                "type": "int",
+                "modifiers": []
               }
             ],
-            "methods": []
+            "methods": [],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/color/output.json b/plantuml/parser/puml_parser/tests/class_diagram/color/output.json
index acdf47ca..f722ffbc 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/color/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/color/output.json
@@ -1,5 +1,5 @@
-{"color.puml":
-  {
+{
+  "color.puml": {
     "name": "color",
     "elements": [
       {
@@ -17,16 +17,23 @@
                 },
                 "namespace": "Service",
                 "package": "",
+                "source_line": 16,
+                "is_abstract": false,
+                "type_aliases": [],
                 "attributes": [],
                 "methods": [
                   {
                     "visibility": "Public",
                     "name": "Request",
-                    "generic_params": [],
                     "params": [],
-                    "type": null
+                    "type": null,
+                    "template_parameters": null,
+                    "modifiers": []
                   }
-                ]
+                ],
+                "template_parameters": null,
+                "extends": [],
+                "implements": []
               }
             }
           ],
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/cpp_style/output.json b/plantuml/parser/puml_parser/tests/class_diagram/cpp_style/output.json
index be5a7e0e..a882cbb8 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/cpp_style/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/cpp_style/output.json
@@ -1,5 +1,5 @@
-{"cpp_style.puml":
-  {
+{
+  "cpp_style.puml": {
     "name": "cpp_style",
     "elements": [
       {
@@ -11,8 +11,14 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [],
-            "methods": []
+            "methods": [],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       },
@@ -25,12 +31,14 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 17,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [],
             "methods": [
               {
                 "visibility": "Public",
                 "name": "Dispatch",
-                "generic_params": [],
                 "params": [
                   {
                     "name": null,
@@ -38,9 +46,14 @@
                     "varargs": true
                   }
                 ],
-                "type": null
+                "type": null,
+                "template_parameters": null,
+                "modifiers": []
               }
-            ]
+            ],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/ctrl_instruct/output.json b/plantuml/parser/puml_parser/tests/class_diagram/ctrl_instruct/output.json
index 08852b70..1db95f98 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/ctrl_instruct/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/ctrl_instruct/output.json
@@ -11,8 +11,14 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 23,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [],
-            "methods": []
+            "methods": [],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       },
@@ -25,8 +31,14 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 24,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [],
-            "methods": []
+            "methods": [],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/empty/output.json b/plantuml/parser/puml_parser/tests/class_diagram/empty/output.json
index 8f944deb..1cb8a88f 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/empty/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/empty/output.json
@@ -1,5 +1,5 @@
-{"empty.puml":
-  {
+{
+  "empty.puml": {
     "name": "",
     "elements": [],
     "relationships": []
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/enum/enum.puml b/plantuml/parser/puml_parser/tests/class_diagram/enum/enum.puml
index de0b972e..d36d09cc 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/enum/enum.puml
+++ b/plantuml/parser/puml_parser/tests/class_diagram/enum/enum.puml
@@ -15,9 +15,9 @@
 enum Status
 
 enum Response {
-    +OK
-    -ERROR
-    #UNKNOWN
+  OK
+  ERROR
+  UNKNOWN
 }
 
 enum State {
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/enum/output.json b/plantuml/parser/puml_parser/tests/class_diagram/enum/output.json
index 3e16edbd..3bcf2b36 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/enum/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/enum/output.json
@@ -1,5 +1,5 @@
-{"enum.puml":
-  {
+{
+  "enum.puml": {
     "name": "enum",
     "elements": [
       {
@@ -10,6 +10,7 @@
           },
           "namespace": "",
           "package": "",
+          "source_line": 15,
           "stereotypes": [],
           "items": []
         }
@@ -22,20 +23,18 @@
           },
           "namespace": "",
           "package": "",
+          "source_line": 17,
           "stereotypes": [],
           "items": [
             {
-              "visibility": "Public",
               "name": "OK",
               "value": null
             },
             {
-              "visibility": "Private",
               "name": "ERROR",
               "value": null
             },
             {
-              "visibility": "Protected",
               "name": "UNKNOWN",
               "value": null
             }
@@ -50,24 +49,22 @@
           },
           "namespace": "",
           "package": "",
+          "source_line": 23,
           "stereotypes": [],
           "items": [
             {
-              "visibility": null,
               "name": "INIT",
               "value": {
                 "Description": "initialize"
               }
             },
             {
-              "visibility": null,
               "name": "RUNNING",
               "value": {
                 "Description": "running"
               }
             },
             {
-              "visibility": null,
               "name": "STOPPED",
               "value": {
                 "Description": "stoped"
@@ -84,17 +81,16 @@
           },
           "namespace": "",
           "package": "",
+          "source_line": 29,
           "stereotypes": [],
           "items": [
             {
-              "visibility": null,
               "name": "HIGH",
               "value": {
                 "Literal": "0"
               }
             },
             {
-              "visibility": null,
               "name": "LOW",
               "value": {
                 "Literal": "1"
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/full_features/full_features.puml b/plantuml/parser/puml_parser/tests/class_diagram/full_features/full_features.puml
index d8e1eb30..be58af90 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/full_features/full_features.puml
+++ b/plantuml/parser/puml_parser/tests/class_diagram/full_features/full_features.puml
@@ -31,7 +31,7 @@ package "pkg1" {
     }
 
     enum E {
-        +A = 1
+        A = 1
         B : desc
         C
     }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/full_features/output.json b/plantuml/parser/puml_parser/tests/class_diagram/full_features/output.json
index f75b9b6d..307b15ad 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/full_features/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/full_features/output.json
@@ -17,33 +17,43 @@
                 },
                 "namespace": "",
                 "package": "pkg1",
+                "source_line": 16,
+                "is_abstract": false,
+                "type_aliases": [],
                 "attributes": [
                   {
                     "visibility": "Public",
                     "name": "id",
-                    "type": "int"
+                    "type": "int",
+                    "modifiers": []
                   },
                   {
                     "visibility": "Private",
                     "name": "name",
-                    "type": "String"
+                    "type": "String",
+                    "modifiers": []
                   },
                   {
                     "visibility": "Protected",
                     "name": "flag",
-                    "type": "bool"
+                    "type": "bool",
+                    "modifiers": []
                   },
                   {
                     "visibility": "Package",
                     "name": "pkgField",
-                    "type": "float"
+                    "type": "float",
+                    "modifiers": []
                   }
                 ],
                 "methods": [
                   {
                     "visibility": "Public",
                     "name": "foo",
-                    "generic_params": ["T", "U"],
+                    "template_parameters": [
+                      "T",
+                      "U"
+                    ],
                     "params": [
                       {
                         "name": "a",
@@ -56,9 +66,13 @@
                         "varargs": true
                       }
                     ],
-                    "type": "bool"
+                    "type": "bool",
+                    "modifiers": []
                   }
-                ]
+                ],
+                "template_parameters": null,
+                "extends": [],
+                "implements": []
               }
             },
             {
@@ -69,14 +83,18 @@
                 },
                 "namespace": "",
                 "package": "pkg1",
+                "source_line": 25,
+                "type_aliases": [],
                 "attributes": [
                   {
                     "visibility": "Public",
                     "name": "value",
-                    "type": "int"
+                    "type": "int",
+                    "modifiers": []
                   }
                 ],
-                "methods": []
+                "methods": [],
+                "template_parameters": null
               }
             },
             {
@@ -87,16 +105,21 @@
                 },
                 "namespace": "",
                 "package": "pkg1",
+                "source_line": 29,
+                "type_aliases": [],
                 "attributes": [],
                 "methods": [
                   {
                     "visibility": "Public",
                     "name": "bar",
-                    "generic_params": [],
                     "params": [],
-                    "type": "void"
+                    "type": "void",
+                    "template_parameters": null,
+                    "modifiers": []
                   }
-                ]
+                ],
+                "template_parameters": null,
+                "extends": []
               }
             },
             {
@@ -107,24 +130,22 @@
                 },
                 "namespace": "",
                 "package": "pkg1",
+                "source_line": 33,
                 "stereotypes": [],
                 "items": [
                   {
-                    "visibility": "Public",
                     "name": "A",
                     "value": {
                       "Literal": "1"
                     }
                   },
                   {
-                    "visibility": null,
                     "name": "B",
                     "value": {
                       "Description": "desc"
                     }
                   },
                   {
-                    "visibility": null,
                     "name": "C",
                     "value": null
                   }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/interface/output.json b/plantuml/parser/puml_parser/tests/class_diagram/interface/output.json
index 1dff1449..4c6b899b 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/interface/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/interface/output.json
@@ -1,5 +1,5 @@
-{"interface.puml":
-  {
+{
+  "interface.puml": {
     "name": "",
     "elements": [
       {
@@ -11,14 +11,19 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "type_aliases": [],
             "attributes": [
               {
                 "visibility": "Public",
                 "name": "doSomething",
-                "type": null
+                "type": null,
+                "modifiers": []
               }
             ],
-            "methods": []
+            "methods": [],
+            "template_parameters": null,
+            "extends": []
           }
         }
       }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/namespace_1/output.json b/plantuml/parser/puml_parser/tests/class_diagram/namespace_1/output.json
index d73bf457..154d3893 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/namespace_1/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/namespace_1/output.json
@@ -1,5 +1,5 @@
-{"namespace_1.puml":
-  {
+{
+  "namespace_1.puml": {
     "name": "namespace_1",
     "elements": [
       {
@@ -17,8 +17,14 @@
                 },
                 "namespace": "Core",
                 "package": "",
+                "source_line": 16,
+                "is_abstract": false,
+                "type_aliases": [],
                 "attributes": [],
-                "methods": []
+                "methods": [],
+                "template_parameters": null,
+                "extends": [],
+                "implements": []
               }
             },
             {
@@ -29,8 +35,14 @@
                 },
                 "namespace": "Core",
                 "package": "",
+                "source_line": 17,
+                "is_abstract": false,
+                "type_aliases": [],
                 "attributes": [],
-                "methods": []
+                "methods": [],
+                "template_parameters": null,
+                "extends": [],
+                "implements": []
               }
             },
             {
@@ -41,15 +53,14 @@
                 },
                 "namespace": "Core",
                 "package": "",
+                "source_line": 19,
                 "stereotypes": [],
                 "items": [
                   {
-                    "visibility": null,
                     "name": "a",
                     "value": null
                   },
                   {
-                    "visibility": null,
                     "name": "b",
                     "value": null
                   }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/namespace_2/output.json b/plantuml/parser/puml_parser/tests/class_diagram/namespace_2/output.json
index 3e069758..26e12d17 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/namespace_2/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/namespace_2/output.json
@@ -1,5 +1,5 @@
-{"namespace_2.puml":
-  {
+{
+  "namespace_2.puml": {
     "name": "namespace_2",
     "elements": [
       {
@@ -24,8 +24,14 @@
                     },
                     "namespace": "UI",
                     "package": "",
+                    "source_line": 17,
+                    "is_abstract": false,
+                    "type_aliases": [],
                     "attributes": [],
-                    "methods": []
+                    "methods": [],
+                    "template_parameters": null,
+                    "extends": [],
+                    "implements": []
                   }
                 }
               ],
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/namespace_3/output.json b/plantuml/parser/puml_parser/tests/class_diagram/namespace_3/output.json
index 85ac31fa..04121b21 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/namespace_3/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/namespace_3/output.json
@@ -1,5 +1,5 @@
-{"namespace_3.puml":
-  {
+{
+  "namespace_3.puml": {
     "name": "namespace_3",
     "elements": [
       {
@@ -11,8 +11,14 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [],
-            "methods": []
+            "methods": [],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       },
@@ -31,8 +37,14 @@
                 },
                 "namespace": "Data",
                 "package": "",
+                "source_line": 18,
+                "is_abstract": false,
+                "type_aliases": [],
                 "attributes": [],
-                "methods": []
+                "methods": [],
+                "template_parameters": null,
+                "extends": [],
+                "implements": []
               }
             }
           ],
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/one_class/output.json b/plantuml/parser/puml_parser/tests/class_diagram/one_class/output.json
index 4343e2d6..93986436 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/one_class/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/one_class/output.json
@@ -1,5 +1,5 @@
-{"one_class.puml":
-  {
+{
+  "one_class.puml": {
     "name": "one_class",
     "elements": [
       {
@@ -11,8 +11,14 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [],
-            "methods": []
+            "methods": [],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/only_attribute/output.json b/plantuml/parser/puml_parser/tests/class_diagram/only_attribute/output.json
index 1fa9f106..306034e9 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/only_attribute/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/only_attribute/output.json
@@ -1,5 +1,5 @@
-{"only_attribute.puml":
-  {
+{
+  "only_attribute.puml": {
     "name": "only_attribute",
     "elements": [
       {
@@ -11,14 +11,21 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [
               {
                 "visibility": "Public",
                 "name": "name",
-                "type": null
+                "type": null,
+                "modifiers": []
               }
             ],
-            "methods": []
+            "methods": [],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/only_method/output.json b/plantuml/parser/puml_parser/tests/class_diagram/only_method/output.json
index 0cc5fd09..0ea856cd 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/only_method/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/only_method/output.json
@@ -1,5 +1,5 @@
-{"only_method.puml":
-  {
+{
+  "only_method.puml": {
     "name": "only_method",
     "elements": [
       {
@@ -11,16 +11,23 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [],
             "methods": [
               {
                 "visibility": "Public",
                 "name": "nodeMethod",
-                "generic_params": [],
                 "params": [],
-                "type": null
+                "type": null,
+                "template_parameters": null,
+                "modifiers": []
               }
-            ]
+            ],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/package/output.json b/plantuml/parser/puml_parser/tests/class_diagram/package/output.json
index bab13674..c0d7f051 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/package/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/package/output.json
@@ -1,5 +1,5 @@
-{"package.puml":
-  {
+{
+  "package.puml": {
     "name": "package",
     "elements": [
       {
@@ -17,8 +17,14 @@
                 },
                 "namespace": "",
                 "package": "Core",
+                "source_line": 16,
+                "is_abstract": false,
+                "type_aliases": [],
                 "attributes": [],
-                "methods": []
+                "methods": [],
+                "template_parameters": null,
+                "extends": [],
+                "implements": []
               }
             },
             {
@@ -29,8 +35,14 @@
                 },
                 "namespace": "",
                 "package": "Core",
+                "source_line": 17,
+                "is_abstract": false,
+                "type_aliases": [],
                 "attributes": [],
-                "methods": []
+                "methods": [],
+                "template_parameters": null,
+                "extends": [],
+                "implements": []
               }
             }
           ],
@@ -61,8 +73,14 @@
                     },
                     "namespace": "",
                     "package": "UI",
+                    "source_line": 22,
+                    "is_abstract": false,
+                    "type_aliases": [],
                     "attributes": [],
-                    "methods": []
+                    "methods": [],
+                    "template_parameters": null,
+                    "extends": [],
+                    "implements": []
                   }
                 }
               ],
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/param/output.json b/plantuml/parser/puml_parser/tests/class_diagram/param/output.json
index 746a8176..b936cfbb 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/param/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/param/output.json
@@ -1,5 +1,5 @@
-{"param.puml":
-  {
+{
+  "param.puml": {
     "name": "param",
     "elements": [
       {
@@ -11,12 +11,14 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [],
             "methods": [
               {
                 "visibility": "Public",
                 "name": "Add",
-                "generic_params": [],
                 "params": [
                   {
                     "name": "a",
@@ -29,9 +31,14 @@
                     "varargs": false
                   }
                 ],
-                "type": "int"
+                "type": "int",
+                "template_parameters": null,
+                "modifiers": []
               }
-            ]
+            ],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/param_templete/output.json b/plantuml/parser/puml_parser/tests/class_diagram/param_templete/output.json
index c8cccb66..7d730961 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/param_templete/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/param_templete/output.json
@@ -1,5 +1,5 @@
-{"param_templete.puml":
-  {
+{
+  "param_templete.puml": {
     "name": "param_templete",
     "elements": [
       {
@@ -11,12 +11,17 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [],
             "methods": [
               {
                 "visibility": "Public",
                 "name": "Create",
-                "generic_params": ["T"],
+                "template_parameters": [
+                  "T"
+                ],
                 "params": [
                   {
                     "name": "id",
@@ -24,9 +29,13 @@
                     "varargs": false
                   }
                 ],
-                "type": null
+                "type": null,
+                "modifiers": []
               }
-            ]
+            ],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/stereotype_definition/output.json b/plantuml/parser/puml_parser/tests/class_diagram/stereotype_definition/output.json
index 8a4e8a45..f1294214 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/stereotype_definition/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/stereotype_definition/output.json
@@ -1,5 +1,5 @@
-{"stereotype_definition.puml":
-  {
+{
+  "stereotype_definition.puml": {
     "name": "stereotype_definition",
     "elements": [
       {
@@ -11,22 +11,30 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [
               {
                 "visibility": "Private",
                 "name": "id",
-                "type": "int"
+                "type": "int",
+                "modifiers": []
               }
             ],
             "methods": [
               {
                 "visibility": "Public",
                 "name": "getName",
-                "generic_params": [],
                 "params": [],
-                "type": "String"
+                "type": "String",
+                "template_parameters": null,
+                "modifiers": []
               }
-            ]
+            ],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       },
@@ -39,14 +47,18 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 20,
+            "type_aliases": [],
             "attributes": [
               {
                 "visibility": "Private",
                 "name": "instance",
-                "type": "Config"
+                "type": "Config",
+                "modifiers": []
               }
             ],
-            "methods": []
+            "methods": [],
+            "template_parameters": null
           }
         }
       },
@@ -59,16 +71,21 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 24,
+            "type_aliases": [],
             "attributes": [],
             "methods": [
               {
                 "visibility": "Public",
                 "name": "doSomething",
-                "generic_params": [],
                 "params": [],
-                "type": "void"
+                "type": "void",
+                "template_parameters": null,
+                "modifiers": []
               }
-            ]
+            ],
+            "template_parameters": null,
+            "extends": []
           }
         }
       },
@@ -80,15 +97,14 @@
           },
           "namespace": "",
           "package": "",
+          "source_line": 28,
           "stereotypes": [],
           "items": [
             {
-              "visibility": null,
               "name": "MALE",
               "value": null
             },
             {
-              "visibility": null,
               "name": "FEMALE",
               "value": null
             }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/stereotype_relationship/output.json b/plantuml/parser/puml_parser/tests/class_diagram/stereotype_relationship/output.json
index cbadf8f7..c5ca50f8 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/stereotype_relationship/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/stereotype_relationship/output.json
@@ -11,8 +11,14 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 15,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [],
-            "methods": []
+            "methods": [],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       },
@@ -25,8 +31,14 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 16,
+            "is_abstract": false,
+            "type_aliases": [],
             "attributes": [],
-            "methods": []
+            "methods": [],
+            "template_parameters": null,
+            "extends": [],
+            "implements": []
           }
         }
       }
diff --git a/plantuml/parser/puml_parser/tests/class_diagram/struct/output.json b/plantuml/parser/puml_parser/tests/class_diagram/struct/output.json
index d8865087..b140d43d 100644
--- a/plantuml/parser/puml_parser/tests/class_diagram/struct/output.json
+++ b/plantuml/parser/puml_parser/tests/class_diagram/struct/output.json
@@ -1,5 +1,5 @@
-{"struct.puml":
-  {
+{
+  "struct.puml": {
     "name": "struct",
     "elements": [
       {
@@ -17,8 +17,11 @@
                 },
                 "namespace": "aaa",
                 "package": "",
+                "source_line": 16,
+                "type_aliases": [],
                 "attributes": [],
-                "methods": []
+                "methods": [],
+                "template_parameters": null
               }
             }
           ],
@@ -34,19 +37,24 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 19,
+            "type_aliases": [],
             "attributes": [
               {
                 "visibility": "Public",
                 "name": "header",
-                "type": "int"
+                "type": "int",
+                "modifiers": []
               },
               {
                 "visibility": "Public",
                 "name": "payload",
-                "type": "string"
+                "type": "string",
+                "modifiers": []
               }
             ],
-            "methods": []
+            "methods": [],
+            "template_parameters": null
           }
         }
       },
@@ -59,19 +67,24 @@
             },
             "namespace": "",
             "package": "",
+            "source_line": 24,
+            "type_aliases": [],
             "attributes": [
               {
                 "visibility": "Public",
                 "name": "id",
-                "type": null
+                "type": null,
+                "modifiers": []
               },
               {
                 "visibility": "Private",
                 "name": "name",
-                "type": null
+                "type": null,
+                "modifiers": []
               }
             ],
-            "methods": []
+            "methods": [],
+            "template_parameters": null
           }
         }
       }
diff --git a/plantuml/parser/puml_resolver/src/class_diagram/src/class_resolver.rs b/plantuml/parser/puml_resolver/src/class_diagram/src/class_resolver.rs
index b739c90f..b5d24331 100644
--- a/plantuml/parser/puml_resolver/src/class_diagram/src/class_resolver.rs
+++ b/plantuml/parser/puml_resolver/src/class_diagram/src/class_resolver.rs
@@ -16,16 +16,46 @@ use class_diagram::Visibility as ResolverVisibility;
 use class_diagram::*;
 use class_parser::Visibility as ParserVisibility;
 use class_parser::{
-    Attribute, ClassUmlFile, ClassUmlTopLevel, Element, EnumDef, EnumValue, Method, Namespace,
-    Package, Param, Relationship,
+    Attribute, ClassUmlFile, ClassUmlTopLevel, Element, EnumDef, EnumValue, Method as ParserMethod,
+    Name, Namespace, Package, Param as ParserParam, Relationship as ParserRelationship,
+    TypeAlias as ParserTypeAlias,
 };
 use parser_core::common_ast::Arrow;
 use resolver_traits::DiagramResolver;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum ClassPumlResolverError {
+    #[error("Class Resolver: Unresolved reference: {reference}")]
+    UnresolvedReference { reference: String },
+
+    #[error("Duplicate entity id: {entity_id}")]
+    DuplicateEntity { entity_id: String },
+
+    #[error("Unknown entity type: {entity_type}")]
+    UnknownEntityType { entity_type: String },
+
+    #[error("Invalid relationship: {from} -> {to}: {reason}")]
+    InvalidRelationship {
+        from: String,
+        to: String,
+        reason: String,
+    },
+
+    #[error("Circular inheritance detected: {cycle}")]
+    CircularInheritance { cycle: String },
+
+    #[error("Invalid visibility modifier: {modifier}")]
+    InvalidVisibility { modifier: String },
+
+    #[error("Parse error: {message}")]
+    ParseError { message: String },
+}
 
 pub struct ClassResolver {
     pub logic: ClassDiagram,
 
-    // simple name -> FQN
+    // internal name or alias -> FQN
     name_map: HashMap<String, String>,
 }
 
@@ -41,7 +71,6 @@ impl ClassResolver {
             logic: ClassDiagram {
                 name: String::new(),
                 entities: Vec::new(),
-                containers: Vec::new(),
                 relationships: Vec::new(),
                 source_files: Vec::new(),
                 version: None,
@@ -50,7 +79,7 @@ impl ClassResolver {
         }
     }
 
-    fn analyze(&mut self, file: &ClassUmlFile) -> Result<(), ClassResolverError> {
+    fn analyze(&mut self, file: &ClassUmlFile) -> Result<(), ClassPumlResolverError> {
         for elem in &file.elements {
             self.process_top_level(elem, None)?;
         }
@@ -63,9 +92,29 @@ impl ClassResolver {
             self.process_relationship(rel, None)?;
         }
 
+        self.populate_entity_relationships();
+
         Ok(())
     }
 
+    fn populate_entity_relationships(&mut self) {
+        let mut outgoing_relationships: HashMap<String, Vec<Relationship>> = HashMap::new();
+
+        for relationship in &self.logic.relationships {
+            outgoing_relationships
+                .entry(relationship.source.clone())
+                .or_default()
+                .push(relationship.clone());
+        }
+
+        for entity in &mut self.logic.entities {
+            entity.relationships = outgoing_relationships
+                .get(&entity.id)
+                .cloned()
+                .unwrap_or_default();
+        }
+    }
+
     pub fn result(self) -> ClassDiagram {
         self.logic
     }
@@ -75,7 +124,7 @@ impl ClassResolver {
             ParserVisibility::Public => ResolverVisibility::Public,
             ParserVisibility::Private => ResolverVisibility::Private,
             ParserVisibility::Protected => ResolverVisibility::Protected,
-            ParserVisibility::Package => ResolverVisibility::Package,
+            ParserVisibility::Package => ResolverVisibility::Private,
         }
     }
 
@@ -102,6 +151,28 @@ impl ClassResolver {
         }
     }
 
+    fn entity_name(name: &Name) -> String {
+        name.display
+            .clone()
+            .unwrap_or_else(|| name.internal.clone())
+    }
+
+    fn current_source_file(&self) -> Option<String> {
+        if self.logic.name.is_empty() {
+            None
+        } else {
+            Some(self.logic.name.clone())
+        }
+    }
+
+    fn register_entity_names(&mut self, name: &Name, id: &str) {
+        self.name_map.insert(name.internal.clone(), id.to_string());
+
+        if let Some(display) = &name.display {
+            self.name_map.insert(display.clone(), id.to_string());
+        }
+    }
+
     fn resolve_name(&self, name: &str, parent: &Option<String>) -> Option<String> {
         // 1. FQN
         if name.contains('.') || name.contains("::") {
@@ -112,19 +183,7 @@ impl ClassResolver {
         if let Some(p) = parent {
             let candidate = format!("{}.{}", p, name);
 
-            // All three checks now verify the candidate actually exists
-            if self.logic.entities.iter().any(|e| e.id == candidate)
-                || self
-                    .logic
-                    .entities
-                    .iter()
-                    .any(|e| e.id == candidate && e.name.as_deref() == Some(name))
-                || self
-                    .logic
-                    .entities
-                    .iter()
-                    .any(|e| e.id == candidate && e.alias.as_deref() == Some(name))
-            {
+            if self.logic.entities.iter().any(|e| e.id == candidate) {
                 return Some(candidate);
             }
         }
@@ -134,13 +193,8 @@ impl ClassResolver {
             return Some(id.clone());
         }
 
-        // 4. Global search name / alias
-        if let Some(e) = self
-            .logic
-            .entities
-            .iter()
-            .find(|e| e.name.as_deref() == Some(name) || e.alias.as_deref() == Some(name))
-        {
+        // 4. Global search exported name
+        if let Some(e) = self.logic.entities.iter().find(|e| e.name == name) {
             return Some(e.id.clone());
         }
 
@@ -151,7 +205,7 @@ impl ClassResolver {
         &mut self,
         elem: &ClassUmlTopLevel,
         parent: Option<String>,
-    ) -> Result<(), ClassResolverError> {
+    ) -> Result<(), ClassPumlResolverError> {
         match elem {
             ClassUmlTopLevel::Types(element) => {
                 self.process_element(element, parent);
@@ -176,7 +230,7 @@ impl ClassResolver {
         &mut self,
         elem: &ClassUmlTopLevel,
         parent: Option<String>,
-    ) -> Result<(), ClassResolverError> {
+    ) -> Result<(), ClassPumlResolverError> {
         match elem {
             ClassUmlTopLevel::Types(element) => {
                 self.process_declared_relations_element(element, parent)?;
@@ -197,16 +251,9 @@ impl ClassResolver {
         &mut self,
         pkg: &Package,
         parent: Option<String>,
-    ) -> Result<(), ClassResolverError> {
+    ) -> Result<(), ClassPumlResolverError> {
         let fqn = self.build_fqn(&pkg.name.internal, &parent);
 
-        self.logic.containers.push(LogicContainer {
-            id: fqn.clone(),
-            name: pkg.name.internal.clone(),
-            parent_id: parent.clone(),
-            container_type: ContainerType::Package,
-        });
-
         for t in &pkg.types {
             self.process_element(t, Some(fqn.clone()));
         }
@@ -226,16 +273,9 @@ impl ClassResolver {
         &mut self,
         ns: &Namespace,
         parent: Option<String>,
-    ) -> Result<(), ClassResolverError> {
+    ) -> Result<(), ClassPumlResolverError> {
         let fqn = self.build_fqn(&ns.name.internal, &parent);
 
-        self.logic.containers.push(LogicContainer {
-            id: fqn.clone(),
-            name: ns.name.internal.clone(),
-            parent_id: parent.clone(),
-            container_type: ContainerType::Namespace,
-        });
-
         for t in &ns.types {
             self.process_element(t, Some(fqn.clone()));
         }
@@ -251,7 +291,7 @@ impl ClassResolver {
         &mut self,
         pkg: &Package,
         parent: Option<String>,
-    ) -> Result<(), ClassResolverError> {
+    ) -> Result<(), ClassPumlResolverError> {
         let fqn = self.build_fqn(&pkg.name.internal, &parent);
 
         for t in &pkg.types {
@@ -269,7 +309,7 @@ impl ClassResolver {
         &mut self,
         ns: &Namespace,
         parent: Option<String>,
-    ) -> Result<(), ClassResolverError> {
+    ) -> Result<(), ClassPumlResolverError> {
         let fqn = self.build_fqn(&ns.name.internal, &parent);
 
         for t in &ns.types {
@@ -287,7 +327,7 @@ impl ClassResolver {
         &mut self,
         element: &Element,
         parent: Option<String>,
-    ) -> Result<(), ClassResolverError> {
+    ) -> Result<(), ClassPumlResolverError> {
         match element {
             Element::ClassDef(def) => {
                 self.process_extends_relationships(
@@ -311,7 +351,7 @@ impl ClassResolver {
         child_name: &str,
         bases: &[String],
         parent: Option<String>,
-    ) -> Result<(), ClassResolverError> {
+    ) -> Result<(), ClassPumlResolverError> {
         self.process_declared_relationships(child_name, bases, parent, RelationType::Inheritance)
     }
 
@@ -320,7 +360,7 @@ impl ClassResolver {
         class_name: &str,
         interfaces: &[String],
         parent: Option<String>,
-    ) -> Result<(), ClassResolverError> {
+    ) -> Result<(), ClassPumlResolverError> {
         self.process_declared_relationships(
             class_name,
             interfaces,
@@ -335,7 +375,7 @@ impl ClassResolver {
         targets: &[String],
         parent: Option<String>,
         relation_type: RelationType,
-    ) -> Result<(), ClassResolverError> {
+    ) -> Result<(), ClassPumlResolverError> {
         if targets.is_empty() {
             return Ok(());
         }
@@ -344,22 +384,17 @@ impl ClassResolver {
 
         for declared_target in targets {
             let target = self.resolve_name(declared_target, &parent).ok_or_else(|| {
-                ClassResolverError::UnresolvedReference {
+                ClassPumlResolverError::UnresolvedReference {
                     reference: declared_target.clone(),
                 }
             })?;
 
-            self.logic.relationships.push(LogicRelationship {
+            self.logic.relationships.push(Relationship {
                 source: source.clone(),
                 target,
                 relation_type,
-                label: None,
-                stereotype: None,
-                // SEARCH_TAG[plantuml-class-gap]: relationship multiplicity/role not exposed by AST.
                 source_multiplicity: None,
                 target_multiplicity: None,
-                source_role: None,
-                target_role: None,
             });
         }
 
@@ -371,9 +406,9 @@ impl ClassResolver {
             Element::EnumDef(def) => self.process_enum(def, parent),
             _ => {
                 let entity_type = match element {
+                    Element::ClassDef(def) if def.is_abstract => EntityType::AbstractClass,
                     Element::ClassDef(_) => EntityType::Class,
                     Element::StructDef(_) => EntityType::Struct,
-                    Element::ObjectDef(_) => EntityType::Object,
                     Element::InterfaceDef(_) => EntityType::Interface,
                     _ => unreachable!(),
                 };
@@ -383,61 +418,83 @@ impl ClassResolver {
     }
 
     fn process_class(&mut self, def: &Element, parent: Option<String>, entity_type: EntityType) {
-        let (name, attributes, methods, template_params) = match def {
-            Element::ClassDef(c) => (&c.name, &c.attributes, &c.methods, &c.template_params),
-            Element::StructDef(s) => (&s.name, &s.attributes, &s.methods, &s.template_params),
-            Element::ObjectDef(o) => (&o.name, &o.attributes, &o.methods, &o.template_params),
-            Element::InterfaceDef(i) => (&i.name, &i.attributes, &i.methods, &i.template_params),
+        let (name, attributes, type_aliases, methods, template_parameters, source_line) = match def
+        {
+            Element::ClassDef(c) => (
+                &c.name,
+                &c.attributes,
+                &c.type_aliases,
+                &c.methods,
+                &c.template_parameters,
+                c.source_line,
+            ),
+            Element::StructDef(s) => (
+                &s.name,
+                &s.attributes,
+                &s.type_aliases,
+                &s.methods,
+                &s.template_parameters,
+                s.source_line,
+            ),
+            Element::InterfaceDef(i) => (
+                &i.name,
+                &i.attributes,
+                &i.type_aliases,
+                &i.methods,
+                &i.template_parameters,
+                i.source_line,
+            ),
             Element::EnumDef(_) => unreachable!("EnumDef should not be passed to process_class"),
         };
 
         let id = self.build_fqn(&name.internal, &parent);
 
-        let entity = LogicEntity {
+        let entity = SimpleEntity {
             id: id.clone(),
-            name: Some(name.internal.clone()),
-            alias: name.display.clone(),
-            parent_id: parent.clone(),
+            name: Self::entity_name(name),
+            enclosing_namespace_id: parent.clone(),
             entity_type,
-            // SEARCH_TAG[plantuml-class-gap]: type stereotypes accepted by grammar but not carried by AST.
-            stereotypes: vec![],
-            attributes: attributes.iter().map(Self::convert_attr).collect(),
+            type_aliases: type_aliases.iter().map(Self::convert_type_alias).collect(),
+            variables: attributes.iter().map(Self::convert_variable).collect(),
             methods: methods
                 .iter()
                 .map(|method| Self::convert_method(method, &name.internal))
                 .collect(),
-            template_params: template_params.clone(),
+            template_parameters: template_parameters.clone(),
             enum_literals: vec![],
-            source_file: None,
-            // SEARCH_TAG[plantuml-class-gap]: per-entity source locations not retained by AST.
-            source_line: None,
+            relationships: vec![],
+            source_file: self.current_source_file(),
+            source_line,
         };
 
-        self.name_map.insert(name.internal.clone(), id.clone());
+        self.register_entity_names(name, &id);
         self.logic.entities.push(entity);
     }
 
-    fn convert_attr(attr: &Attribute) -> LogicAttribute {
+    fn convert_type_alias(type_alias: &ParserTypeAlias) -> TypeAlias {
+        TypeAlias {
+            alias: type_alias.alias.clone(),
+            original_type: type_alias.original_type.clone(),
+        }
+    }
+
+    fn convert_variable(attr: &Attribute) -> MemberVariable {
         fn has_modifier(modifiers: &[String], expected: &str) -> bool {
             modifiers
                 .iter()
                 .any(|modifier| ClassResolver::normalize_modifier(modifier) == expected)
         }
 
-        LogicAttribute {
+        MemberVariable {
             name: attr.name.clone(),
             data_type: attr.r#type.clone(),
             visibility: Self::map_visibility(attr.visibility.clone()),
-            // SEARCH_TAG[plantuml-class-gap]: attribute initializer not represented by AST.
-            default_value: None,
             is_static: has_modifier(&attr.modifiers, "static"),
             is_const: has_modifier(&attr.modifiers, "const"),
-            // SEARCH_TAG[plantuml-class-gap]: attribute description/doc not represented by AST.
-            description: None,
         }
     }
 
-    fn convert_method(m: &Method, owner_name: &str) -> LogicMethod {
+    fn convert_method(m: &ParserMethod, owner_name: &str) -> Method {
         fn has_modifier(modifiers: &[String], expected: &str) -> bool {
             modifiers
                 .iter()
@@ -447,21 +504,20 @@ impl ClassResolver {
         let is_constructor = m.name == owner_name;
         let is_destructor = m.name == format!("~{}", owner_name);
 
-        LogicMethod {
+        Method {
             name: m.name.clone(),
             return_type: m.r#type.clone(),
             visibility: Self::map_visibility(m.visibility.clone()),
             parameters: m.params.iter().map(Self::convert_param).collect(),
-            template_params: m.generic_params.clone(),
-            is_static: has_modifier(&m.modifiers, "static"),
-            is_const: has_modifier(&m.modifiers, "const"),
-            // SEARCH_TAG[plantuml-class-gap]: virtual modifier not represented by grammar/AST.
-            is_virtual: false,
-            is_abstract: has_modifier(&m.modifiers, "abstract"),
-            // SEARCH_TAG[plantuml-class-gap]: override modifier not represented by grammar/AST.
-            is_override: false,
-            is_constructor,
-            is_destructor,
+            template_parameters: m.template_parameters.clone(),
+            modifiers: MethodModifier::make_modifier_vec(
+                has_modifier(&m.modifiers, "static"),
+                false,
+                has_modifier(&m.modifiers, "abstract"),
+                false,
+                is_constructor,
+                is_destructor,
+            ),
         }
     }
 
@@ -474,25 +530,10 @@ impl ClassResolver {
             .trim()
     }
 
-    fn is_reference_type(raw_type: &str) -> bool {
-        let trimmed = raw_type.trim();
-        trimmed.ends_with("&&") || trimmed.ends_with('&')
-    }
-
-    fn is_const_type(raw_type: &str) -> bool {
-        raw_type.trim_start().starts_with("const ")
-    }
-
-    fn convert_param(param: &Param) -> LogicParameter {
-        let param_type = param.param_type.clone();
-
-        LogicParameter {
+    fn convert_param(param: &ParserParam) -> FunctionArgument {
+        FunctionArgument {
             name: param.name.clone().unwrap_or_default(),
-            param_type: param_type.clone(),
-            // SEARCH_TAG[plantuml-class-gap]: parameter default value not represented by AST.
-            default_value: None,
-            is_reference: param_type.as_deref().is_some_and(Self::is_reference_type),
-            is_const: param_type.as_deref().is_some_and(Self::is_const_type),
+            param_type: param.param_type.clone(),
             is_variadic: param.varargs,
         }
     }
@@ -503,44 +544,35 @@ impl ClassResolver {
         let literals = def
             .items
             .iter()
-            .map(|item| LogicEnumLiteral {
+            .map(|item| EnumLiteral {
                 name: item.name.clone(),
-                visibility: item
-                    .visibility
-                    .clone()
-                    .map(Self::map_visibility)
-                    .unwrap_or(ResolverVisibility::Public),
                 value: match &item.value {
                     Some(EnumValue::Literal(v)) => Some(v.clone()),
-                    // SEARCH_TAG[plantuml-class-gap]: enum description payload folded into value.
                     Some(EnumValue::Description(d)) => Some(d.clone()),
                     None => None,
                 },
-                // SEARCH_TAG[plantuml-class-gap]: enum literal description not emitted separately.
-                description: None,
             })
             .collect();
 
-        self.logic.entities.push(LogicEntity {
+        self.logic.entities.push(SimpleEntity {
             id: id.clone(),
-            name: def.name.display.clone(),
-            alias: None,
-            parent_id: parent.clone(),
+            name: Self::entity_name(&def.name),
+            enclosing_namespace_id: parent.clone(),
             entity_type: EntityType::Enum,
-            stereotypes: def.stereotypes.clone(),
-            attributes: vec![],
+            type_aliases: vec![],
+            variables: vec![],
             methods: vec![],
-            template_params: vec![],
+            template_parameters: None,
             enum_literals: literals,
-            source_file: None,
-            // SEARCH_TAG[plantuml-class-gap]: per-entity source locations not retained by AST.
-            source_line: None,
+            relationships: vec![],
+            source_file: self.current_source_file(),
+            source_line: def.source_line,
         });
 
-        self.name_map.insert(def.name.internal.clone(), id);
+        self.register_entity_names(&def.name, &id);
     }
 
-    fn convert_arrow(&self, arrow: &Arrow) -> Result<(RelationType, bool), ClassResolverError> {
+    fn convert_arrow(&self, arrow: &Arrow) -> Result<(RelationType, bool), ClassPumlResolverError> {
         let left = arrow.left.as_ref().map(|d| d.raw.as_str()).unwrap_or("");
         let line = arrow.line.raw.as_str();
         let right = arrow.right.as_ref().map(|d| d.raw.as_str()).unwrap_or("");
@@ -582,11 +614,6 @@ impl ClassResolver {
             return Ok((RelationType::Aggregation, false));
         }
 
-        // ---------------- Decorated undirected link ----------------
-        if left == "+" || right == "+" {
-            return Ok((RelationType::Link, false));
-        }
-
         // ---------------- Association ----------------
         if line == "-" && right == ">" {
             return Ok((RelationType::Association, false));
@@ -609,19 +636,7 @@ impl ClassResolver {
             return Ok((RelationType::Dependency, true));
         }
 
-        // ---------------- Undirected ----------------
-        if line == "-" {
-            return Ok((RelationType::Link, false));
-        }
-        if line == "--" {
-            return Ok((RelationType::Link, false));
-        }
-
-        if line == ".." {
-            return Ok((RelationType::DashedLink, false));
-        }
-
-        Err(ClassResolverError::InvalidRelationship {
+        Err(ClassPumlResolverError::InvalidRelationship {
             from: left.to_string(),
             to: right.to_string(),
             reason: format!("Unsupported arrow pattern: {}{}{}", left, line, right),
@@ -630,17 +645,17 @@ impl ClassResolver {
 
     fn process_relationship(
         &mut self,
-        rel: &Relationship,
+        rel: &ParserRelationship,
         parent: Option<String>,
-    ) -> Result<(), ClassResolverError> {
+    ) -> Result<(), ClassPumlResolverError> {
         let left = self.resolve_name(&rel.left, &parent).ok_or_else(|| {
-            ClassResolverError::UnresolvedReference {
+            ClassPumlResolverError::UnresolvedReference {
                 reference: rel.left.clone(),
             }
         })?;
 
         let right = self.resolve_name(&rel.right, &parent).ok_or_else(|| {
-            ClassResolverError::UnresolvedReference {
+            ClassPumlResolverError::UnresolvedReference {
                 reference: rel.right.clone(),
             }
         })?;
@@ -653,34 +668,24 @@ impl ClassResolver {
             (left, right)
         };
 
-        let (label, stereotype) = match &rel.label {
-            Some(text) => {
-                let trimmed = text.trim();
-                if trimmed.starts_with("<<") && trimmed.ends_with(">>") {
-                    let inner = trimmed
-                        .trim_start_matches("<<")
-                        .trim_end_matches(">>")
-                        .trim()
-                        .to_string();
-                    (None, Some(inner))
-                } else {
-                    (Some(text.clone()), None)
-                }
-            }
-            None => (None, None),
+        let (source_multiplicity, target_multiplicity) = if reversed {
+            (
+                rel.right_multiplicity.clone(),
+                rel.left_multiplicity.clone(),
+            )
+        } else {
+            (
+                rel.left_multiplicity.clone(),
+                rel.right_multiplicity.clone(),
+            )
         };
 
-        self.logic.relationships.push(LogicRelationship {
+        self.logic.relationships.push(Relationship {
             source: source_id,
             target: target_id,
             relation_type,
-            label,
-            stereotype,
-            // SEARCH_TAG[plantuml-class-gap]: relationship multiplicity/role not exposed by AST.
-            source_multiplicity: None,
-            target_multiplicity: None,
-            source_role: None,
-            target_role: None,
+            source_multiplicity,
+            target_multiplicity,
         });
 
         Ok(())
@@ -691,7 +696,7 @@ impl DiagramResolver for ClassResolver {
     type Document = ClassUmlFile;
     type Statement = ();
     type Output = ClassDiagram;
-    type Error = ClassResolverError;
+    type Error = ClassPumlResolverError;
 
     fn visit_document(&mut self, document: &Self::Document) -> Result<Self::Output, Self::Error> {
         self.name_map.clear();
@@ -706,7 +711,6 @@ impl DiagramResolver for ClassResolver {
             ClassDiagram {
                 name: String::new(),
                 entities: Vec::new(),
-                containers: Vec::new(),
                 relationships: Vec::new(),
                 source_files: Vec::new(),
                 version: None,
@@ -720,7 +724,7 @@ impl DiagramResolver for ClassResolver {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use class_parser::{ClassDef, EnumItem, InterfaceDef, Name, ObjectDef, StructDef};
+    use class_parser::{ClassDef, EnumItem, Name};
     use parser_core::common_ast::{ArrowDecor, ArrowLine};
 
     // ----------------------------
@@ -738,10 +742,13 @@ mod tests {
             name: make_name(name),
             namespace: "".to_string(),
             package: "".to_string(),
-            template_params: vec![],
+            source_line: None,
+            is_abstract: false,
+            template_parameters: None,
             extends: vec![],
             implements: vec![],
             attributes: vec![],
+            type_aliases: vec![],
             methods: vec![],
         })
     }
@@ -751,12 +758,12 @@ mod tests {
             name: make_name(name),
             namespace: "".to_string(),
             package: "".to_string(),
+            source_line: None,
             stereotypes: vec![],
             items: items
                 .into_iter()
                 .map(|n| EnumItem {
                     name: n.to_string(),
-                    visibility: Some(ParserVisibility::Public),
                     value: None,
                 })
                 .collect(),
@@ -813,7 +820,7 @@ mod tests {
 
         let entity = &resolver.logic.entities[0];
         assert_eq!(entity.id, "User");
-        assert_eq!(entity.name.as_deref(), Some("User"));
+        assert_eq!(entity.name, "User");
         assert_eq!(entity.entity_type, EntityType::Class);
     }
 
@@ -917,16 +924,6 @@ mod tests {
                 expected_ty: RelationType::Dependency,
                 expected_reversed: true,
             },
-            Case {
-                arrow: make_arrow(None, "--", None),
-                expected_ty: RelationType::Link,
-                expected_reversed: false,
-            },
-            Case {
-                arrow: make_arrow(None, "..", None),
-                expected_ty: RelationType::DashedLink,
-                expected_reversed: false,
-            },
         ];
 
         for (i, case) in cases.into_iter().enumerate() {
@@ -945,11 +942,20 @@ mod tests {
     fn test_convert_arrow_invalid() {
         let resolver = ClassResolver::new();
 
-        let arrow = make_arrow(Some("?"), "~~", Some("?"));
-
-        let result = resolver.convert_arrow(&arrow);
+        let invalid_cases = vec![
+            make_arrow(Some("?"), "~~", Some("?")),
+            make_arrow(None, "--", None),
+            make_arrow(None, "..", None),
+            make_arrow(Some("+"), "-", None),
+        ];
 
-        assert!(result.is_err());
+        for arrow in invalid_cases {
+            let result = resolver.convert_arrow(&arrow);
+            assert!(matches!(
+                result,
+                Err(ClassPumlResolverError::InvalidRelationship { .. })
+            ));
+        }
     }
 
     // ----------------------------
@@ -962,10 +968,12 @@ mod tests {
         resolver.process_element(&make_class("A"), None);
         resolver.process_element(&make_class("B"), None);
 
-        let rel = Relationship {
+        let rel = ParserRelationship {
             left: "A".to_string(),
             right: "B".to_string(),
             arrow: make_arrow(Some("<|"), "--", None),
+            left_multiplicity: None,
+            right_multiplicity: None,
             label: Some("<<label>>".to_string()),
         };
 
@@ -977,18 +985,18 @@ mod tests {
         assert_eq!(r.source, "B");
         assert_eq!(r.target, "A");
         assert_eq!(r.relation_type, RelationType::Inheritance);
-        assert_eq!(r.label, None);
-        assert_eq!(r.stereotype, Some("label".to_string()));
     }
 
     #[test]
     fn test_process_relationship_unresolved_left() {
         let mut resolver = ClassResolver::new();
 
-        let rel = Relationship {
+        let rel = ParserRelationship {
             left: "UnknownA".to_string(),
             right: "KnownB".to_string(),
             arrow: make_arrow(None, "--", Some(">")),
+            left_multiplicity: None,
+            right_multiplicity: None,
             label: None,
         };
 
@@ -996,7 +1004,7 @@ mod tests {
 
         assert!(matches!(
             result,
-            Err(ClassResolverError::UnresolvedReference { ref reference }) if reference == "UnknownA"
+            Err(ClassPumlResolverError::UnresolvedReference { ref reference }) if reference == "UnknownA"
         ));
     }
 
@@ -1015,13 +1023,9 @@ mod tests {
 
         resolver.process_namespace(&ns, None).unwrap();
 
-        assert_eq!(resolver.logic.containers.len(), 1);
         assert_eq!(resolver.logic.entities.len(), 1);
 
-        let container = &resolver.logic.containers[0];
         let entity = &resolver.logic.entities[0];
-        assert_eq!(container.id, "core.geometry");
-        assert_eq!(container.name, "core::geometry");
         assert_eq!(entity.id, "core.geometry.User");
     }
 
@@ -1042,6 +1046,8 @@ mod tests {
         assert_eq!(logic.name, "test");
         assert_eq!(logic.entities.len(), 1);
         assert_eq!(logic.entities[0].id, "User");
+        assert!(logic.entities[0].relationships.is_empty());
+        assert_eq!(logic.entities[0].source_file.as_deref(), Some("test"));
     }
 
     // ----------------------------
@@ -1054,8 +1060,9 @@ mod tests {
                 name: make_name("MyEnum"),
                 namespace: "".to_string(),
                 package: "".to_string(),
-                items: vec![],
+                source_line: None,
                 stereotypes: vec![],
+                items: vec![],
             }),
             ClassUmlTopLevel::Namespace(Namespace {
                 name: make_name("ns"),
diff --git a/plantuml/parser/puml_resolver/src/class_diagram/src/lib.rs b/plantuml/parser/puml_resolver/src/class_diagram/src/lib.rs
index 74e5e8d3..55e3ee55 100644
--- a/plantuml/parser/puml_resolver/src/class_diagram/src/lib.rs
+++ b/plantuml/parser/puml_resolver/src/class_diagram/src/lib.rs
@@ -12,4 +12,4 @@
 // *******************************************************************************
 mod class_resolver;
 
-pub use class_resolver::ClassResolver;
+pub use class_resolver::{ClassPumlResolverError, ClassResolver};
diff --git a/plantuml/parser/puml_resolver/src/class_diagram/test/class_resolver_test.rs b/plantuml/parser/puml_resolver/src/class_diagram/test/class_resolver_test.rs
index 299b50c5..a7cff64d 100644
--- a/plantuml/parser/puml_resolver/src/class_diagram/test/class_resolver_test.rs
+++ b/plantuml/parser/puml_resolver/src/class_diagram/test/class_resolver_test.rs
@@ -15,9 +15,9 @@ use std::fs;
 use std::path::PathBuf;
 use std::rc::Rc;
 
-use class_diagram::{ClassDiagram, ClassResolverError};
+use class_diagram::ClassDiagram;
 use class_parser::PumlClassParser;
-use class_resolver::ClassResolver;
+use class_resolver::{ClassPumlResolverError, ClassResolver};
 
 use parser_core::DiagramParser;
 use puml_utils::LogLevel;
@@ -28,12 +28,12 @@ use test_framework::{run_case, DefaultExpectationChecker, DiagramProcessor};
 struct ClassResolverRunner;
 impl DiagramProcessor for ClassResolverRunner {
     type Output = ClassDiagram;
-    type Error = ClassResolverError;
+    type Error = ClassPumlResolverError;
 
     fn run(
         &self,
         files: &HashSet<Rc<PathBuf>>,
-    ) -> Result<HashMap<Rc<PathBuf>, ClassDiagram>, ClassResolverError> {
+    ) -> Result<HashMap<Rc<PathBuf>, ClassDiagram>, ClassPumlResolverError> {
         let mut results = HashMap::new();
         let mut parser = PumlClassParser;
         let mut resolver = ClassResolver::new();
diff --git a/plantuml/parser/puml_serializer/src/serialize/class_serializer.rs b/plantuml/parser/puml_serializer/src/serialize/class_serializer.rs
index c3157f62..079560e1 100644
--- a/plantuml/parser/puml_serializer/src/serialize/class_serializer.rs
+++ b/plantuml/parser/puml_serializer/src/serialize/class_serializer.rs
@@ -12,8 +12,8 @@
 // *******************************************************************************
 
 use class_diagram::{
-    ClassDiagram, ContainerType, EntityType, LogicAttribute, LogicContainer, LogicEntity,
-    LogicEnumLiteral, LogicMethod, LogicParameter, LogicRelationship, RelationType, Visibility,
+    ClassDiagram, EntityType, EnumLiteral, FunctionArgument, MemberVariable, Method,
+    MethodModifier, RelationType, Relationship, SimpleEntity, TypeAlias, Visibility,
 };
 use class_fbs::class_metamodel as fb;
 use flatbuffers::FlatBufferBuilder;
@@ -35,13 +35,6 @@ impl ClassSerializer {
             .collect();
         let entities_offset = builder.create_vector(&entity_offsets);
 
-        let container_offsets: Vec<_> = diagram
-            .containers
-            .iter()
-            .map(|container| Self::serialize_container(&mut builder, container))
-            .collect();
-        let containers_offset = builder.create_vector(&container_offsets);
-
         let relationship_offsets: Vec<_> = diagram
             .relationships
             .iter()
@@ -56,14 +49,16 @@ impl ClassSerializer {
             .collect();
         let source_files_offset = builder.create_vector(&source_offsets);
 
-        let version_offset = diagram.version.as_ref().map(|v| builder.create_string(v));
+        let version_offset = diagram
+            .version
+            .as_ref()
+            .map(|version| builder.create_string(version));
 
         let root = fb::ClassDiagram::create(
             &mut builder,
             &fb::ClassDiagramArgs {
                 name: Some(name_offset),
                 entities: Some(entities_offset),
-                containers: Some(containers_offset),
                 relationships: Some(relationships_offset),
                 source_files: Some(source_files_offset),
                 version: version_offset,
@@ -76,32 +71,28 @@ impl ClassSerializer {
 
     fn serialize_entity<'a>(
         builder: &mut FlatBufferBuilder<'a>,
-        entity: &LogicEntity,
-    ) -> flatbuffers::WIPOffset<fb::Entity<'a>> {
+        entity: &SimpleEntity,
+    ) -> flatbuffers::WIPOffset<fb::SimpleEntity<'a>> {
         let id_offset = builder.create_string(&entity.id);
-        let name_offset = entity.name.as_ref().map(|name| builder.create_string(name));
-        let alias_offset = entity
-            .alias
-            .as_ref()
-            .map(|alias| builder.create_string(alias));
-        let parent_offset = entity
-            .parent_id
+        let name_offset = builder.create_string(&entity.name);
+        let enclosing_namespace_id_offset = entity
+            .enclosing_namespace_id
             .as_ref()
-            .map(|parent| builder.create_string(parent));
+            .map(|namespace| builder.create_string(namespace));
 
-        let stereotype_offsets: Vec<_> = entity
-            .stereotypes
+        let type_alias_offsets: Vec<_> = entity
+            .type_aliases
             .iter()
-            .map(|st| builder.create_string(st))
+            .map(|type_alias| Self::serialize_type_alias(builder, type_alias))
             .collect();
-        let stereotypes_offset = builder.create_vector(&stereotype_offsets);
+        let type_aliases_offset = builder.create_vector(&type_alias_offsets);
 
-        let attribute_offsets: Vec<_> = entity
-            .attributes
+        let variable_offsets: Vec<_> = entity
+            .variables
             .iter()
-            .map(|attr| Self::serialize_attribute(builder, attr))
+            .map(|variable| Self::serialize_variable(builder, variable))
             .collect();
-        let attributes_offset = builder.create_vector(&attribute_offsets);
+        let variables_offset = builder.create_vector(&variable_offsets);
 
         let method_offsets: Vec<_> = entity
             .methods
@@ -110,12 +101,13 @@ impl ClassSerializer {
             .collect();
         let methods_offset = builder.create_vector(&method_offsets);
 
-        let template_offsets: Vec<_> = entity
-            .template_params
-            .iter()
-            .map(|param| builder.create_string(param))
-            .collect();
-        let template_params_offset = builder.create_vector(&template_offsets);
+        let template_parameters_offset = entity.template_parameters.as_ref().map(|parameters| {
+            let template_offsets: Vec<_> = parameters
+                .iter()
+                .map(|parameter| builder.create_string(parameter))
+                .collect();
+            builder.create_vector(&template_offsets)
+        });
 
         let enum_literal_offsets: Vec<_> = entity
             .enum_literals
@@ -124,65 +116,78 @@ impl ClassSerializer {
             .collect();
         let enum_literals_offset = builder.create_vector(&enum_literal_offsets);
 
+        let entity_relationship_offsets: Vec<_> = entity
+            .relationships
+            .iter()
+            .map(|relationship| Self::serialize_relationship(builder, relationship))
+            .collect();
+        let entity_relationships_offset = builder.create_vector(&entity_relationship_offsets);
+
         let source_file_offset = entity
             .source_file
             .as_ref()
             .map(|source| builder.create_string(source));
 
-        fb::Entity::create(
+        fb::SimpleEntity::create(
             builder,
-            &fb::EntityArgs {
+            &fb::SimpleEntityArgs {
                 id: Some(id_offset),
-                name: name_offset,
-                alias: alias_offset,
-                parent_id: parent_offset,
+                name: Some(name_offset),
+                enclosing_namespace_id: enclosing_namespace_id_offset,
                 entity_type: Self::map_entity_type(entity.entity_type),
-                stereotypes: Some(stereotypes_offset),
-                attributes: Some(attributes_offset),
+                type_aliases: Some(type_aliases_offset),
+                variables: Some(variables_offset),
                 methods: Some(methods_offset),
-                template_params: Some(template_params_offset),
+                template_parameters: template_parameters_offset,
                 enum_literals: Some(enum_literals_offset),
+                relationships: Some(entity_relationships_offset),
                 source_file: source_file_offset,
                 source_line: entity.source_line.unwrap_or(UNKNOWN_SOURCE_LINE),
             },
         )
     }
 
-    fn serialize_attribute<'a>(
+    fn serialize_type_alias<'a>(
+        builder: &mut FlatBufferBuilder<'a>,
+        type_alias: &TypeAlias,
+    ) -> flatbuffers::WIPOffset<fb::TypeAlias<'a>> {
+        let alias_offset = builder.create_string(&type_alias.alias);
+        let original_type_offset = builder.create_string(&type_alias.original_type);
+
+        fb::TypeAlias::create(
+            builder,
+            &fb::TypeAliasArgs {
+                alias: Some(alias_offset),
+                original_type: Some(original_type_offset),
+            },
+        )
+    }
+
+    fn serialize_variable<'a>(
         builder: &mut FlatBufferBuilder<'a>,
-        attr: &LogicAttribute,
-    ) -> flatbuffers::WIPOffset<fb::Attribute<'a>> {
-        let name_offset = builder.create_string(&attr.name);
-        let data_type_offset = attr
+        variable: &MemberVariable,
+    ) -> flatbuffers::WIPOffset<fb::MemberVariable<'a>> {
+        let name_offset = builder.create_string(&variable.name);
+        let data_type_offset = variable
             .data_type
             .as_ref()
             .map(|data_type| builder.create_string(data_type));
-        let default_value_offset = attr
-            .default_value
-            .as_ref()
-            .map(|value| builder.create_string(value));
-        let description_offset = attr
-            .description
-            .as_ref()
-            .map(|description| builder.create_string(description));
 
-        fb::Attribute::create(
+        fb::MemberVariable::create(
             builder,
-            &fb::AttributeArgs {
+            &fb::MemberVariableArgs {
                 name: Some(name_offset),
                 data_type: data_type_offset,
-                visibility: Self::map_visibility(attr.visibility),
-                default_value: default_value_offset,
-                is_static: attr.is_static,
-                is_const: attr.is_const,
-                description: description_offset,
+                visibility: Self::map_visibility(variable.visibility),
+                is_static: variable.is_static,
+                is_const: variable.is_const,
             },
         )
     }
 
     fn serialize_method<'a>(
         builder: &mut FlatBufferBuilder<'a>,
-        method: &LogicMethod,
+        method: &Method,
     ) -> flatbuffers::WIPOffset<fb::Method<'a>> {
         let name_offset = builder.create_string(&method.name);
         let return_type_offset = method
@@ -193,16 +198,24 @@ impl ClassSerializer {
         let parameter_offsets: Vec<_> = method
             .parameters
             .iter()
-            .map(|param| Self::serialize_parameter(builder, param))
+            .map(|parameter| Self::serialize_parameter(builder, parameter))
             .collect();
         let parameters_offset = builder.create_vector(&parameter_offsets);
 
-        let template_offsets: Vec<_> = method
-            .template_params
+        let template_parameters_offset = method.template_parameters.as_ref().map(|parameters| {
+            let template_offsets: Vec<_> = parameters
+                .iter()
+                .map(|parameter| builder.create_string(parameter))
+                .collect();
+            builder.create_vector(&template_offsets)
+        });
+
+        let modifier_values: Vec<_> = method
+            .modifiers
             .iter()
-            .map(|param| builder.create_string(param))
+            .map(Self::map_method_modifier)
             .collect();
-        let template_params_offset = builder.create_vector(&template_offsets);
+        let modifiers_offset = builder.create_vector(&modifier_values);
 
         fb::Method::create(
             builder,
@@ -211,40 +224,27 @@ impl ClassSerializer {
                 return_type: return_type_offset,
                 visibility: Self::map_visibility(method.visibility),
                 parameters: Some(parameters_offset),
-                template_params: Some(template_params_offset),
-                is_static: method.is_static,
-                is_const: method.is_const,
-                is_virtual: method.is_virtual,
-                is_abstract: method.is_abstract,
-                is_override: method.is_override,
-                is_constructor: method.is_constructor,
-                is_destructor: method.is_destructor,
+                template_parameters: template_parameters_offset,
+                modifiers: Some(modifiers_offset),
             },
         )
     }
 
     fn serialize_parameter<'a>(
         builder: &mut FlatBufferBuilder<'a>,
-        param: &LogicParameter,
-    ) -> flatbuffers::WIPOffset<fb::Parameter<'a>> {
+        param: &FunctionArgument,
+    ) -> flatbuffers::WIPOffset<fb::FunctionArgument<'a>> {
         let name_offset = builder.create_string(&param.name);
         let param_type_offset = param
             .param_type
             .as_ref()
             .map(|param_type| builder.create_string(param_type));
-        let default_value_offset = param
-            .default_value
-            .as_ref()
-            .map(|value| builder.create_string(value));
 
-        fb::Parameter::create(
+        fb::FunctionArgument::create(
             builder,
-            &fb::ParameterArgs {
+            &fb::FunctionArgumentArgs {
                 name: Some(name_offset),
                 param_type: param_type_offset,
-                default_value: default_value_offset,
-                is_reference: param.is_reference,
-                is_const: param.is_const,
                 is_variadic: param.is_variadic,
             },
         )
@@ -252,65 +252,29 @@ impl ClassSerializer {
 
     fn serialize_enum_literal<'a>(
         builder: &mut FlatBufferBuilder<'a>,
-        literal: &LogicEnumLiteral,
+        literal: &EnumLiteral,
     ) -> flatbuffers::WIPOffset<fb::EnumLiteral<'a>> {
         let name_offset = builder.create_string(&literal.name);
         let value_offset = literal
             .value
             .as_ref()
             .map(|value| builder.create_string(value));
-        let description_offset = literal
-            .description
-            .as_ref()
-            .map(|description| builder.create_string(description));
 
         fb::EnumLiteral::create(
             builder,
             &fb::EnumLiteralArgs {
                 name: Some(name_offset),
-                visibility: Self::map_visibility(literal.visibility),
                 value: value_offset,
-                description: description_offset,
-            },
-        )
-    }
-
-    fn serialize_container<'a>(
-        builder: &mut FlatBufferBuilder<'a>,
-        container: &LogicContainer,
-    ) -> flatbuffers::WIPOffset<fb::Container<'a>> {
-        let id_offset = builder.create_string(&container.id);
-        let name_offset = builder.create_string(&container.name);
-        let parent_offset = container
-            .parent_id
-            .as_ref()
-            .map(|parent| builder.create_string(parent));
-
-        fb::Container::create(
-            builder,
-            &fb::ContainerArgs {
-                id: Some(id_offset),
-                name: Some(name_offset),
-                parent_id: parent_offset,
-                container_type: Self::map_container_type(container.container_type),
             },
         )
     }
 
     fn serialize_relationship<'a>(
         builder: &mut FlatBufferBuilder<'a>,
-        relationship: &LogicRelationship,
+        relationship: &Relationship,
     ) -> flatbuffers::WIPOffset<fb::Relationship<'a>> {
         let source_offset = builder.create_string(&relationship.source);
         let target_offset = builder.create_string(&relationship.target);
-        let label_offset = relationship
-            .label
-            .as_ref()
-            .map(|label| builder.create_string(label));
-        let stereotype_offset = relationship
-            .stereotype
-            .as_ref()
-            .map(|stereotype| builder.create_string(stereotype));
         let source_multiplicity_offset = relationship
             .source_multiplicity
             .as_ref()
@@ -319,14 +283,6 @@ impl ClassSerializer {
             .target_multiplicity
             .as_ref()
             .map(|multiplicity| builder.create_string(multiplicity));
-        let source_role_offset = relationship
-            .source_role
-            .as_ref()
-            .map(|role| builder.create_string(role));
-        let target_role_offset = relationship
-            .target_role
-            .as_ref()
-            .map(|role| builder.create_string(role));
 
         fb::Relationship::create(
             builder,
@@ -334,12 +290,8 @@ impl ClassSerializer {
                 source: Some(source_offset),
                 target: Some(target_offset),
                 relation_type: Self::map_relation_type(relationship.relation_type),
-                label: label_offset,
-                stereotype: stereotype_offset,
                 source_multiplicity: source_multiplicity_offset,
                 target_multiplicity: target_multiplicity_offset,
-                source_role: source_role_offset,
-                target_role: target_role_offset,
             },
         )
     }
@@ -349,7 +301,6 @@ impl ClassSerializer {
             Visibility::Public => fb::Visibility::Public,
             Visibility::Private => fb::Visibility::Private,
             Visibility::Protected => fb::Visibility::Protected,
-            Visibility::Package => fb::Visibility::Package,
         }
     }
 
@@ -357,18 +308,21 @@ impl ClassSerializer {
         match t {
             EntityType::Class => fb::EntityType::Class,
             EntityType::Struct => fb::EntityType::Struct,
-            EntityType::Object => fb::EntityType::Object,
             EntityType::Interface => fb::EntityType::Interface,
-            EntityType::Enum => fb::EntityType::Enum,
             EntityType::AbstractClass => fb::EntityType::AbstractClass,
-            EntityType::Annotation => fb::EntityType::Annotation,
+            EntityType::Enum => fb::EntityType::Enum,
         }
     }
 
-    fn map_container_type(t: ContainerType) -> fb::ContainerType {
+    fn map_method_modifier(t: &MethodModifier) -> fb::MethodModifier {
         match t {
-            ContainerType::Namespace => fb::ContainerType::Namespace,
-            ContainerType::Package => fb::ContainerType::Package,
+            MethodModifier::Static => fb::MethodModifier::Static,
+            MethodModifier::Virtual => fb::MethodModifier::Virtual,
+            MethodModifier::Abstract => fb::MethodModifier::Abstract,
+            MethodModifier::Override => fb::MethodModifier::Override,
+            MethodModifier::Constructor => fb::MethodModifier::Constructor,
+            MethodModifier::Destructor => fb::MethodModifier::Destructor,
+            MethodModifier::Noexcept => fb::MethodModifier::Noexcept,
         }
     }
 
@@ -380,8 +334,6 @@ impl ClassSerializer {
             RelationType::Aggregation => fb::RelationType::Aggregation,
             RelationType::Association => fb::RelationType::Association,
             RelationType::Dependency => fb::RelationType::Dependency,
-            RelationType::Link => fb::RelationType::Link,
-            RelationType::DashedLink => fb::RelationType::DashedLink,
         }
     }
 }
diff --git a/tools/metamodel/schema/class_diagram.fbs b/tools/metamodel/schema/class_diagram.fbs
index 41f31f20..a9c1c336 100644
--- a/tools/metamodel/schema/class_diagram.fbs
+++ b/tools/metamodel/schema/class_diagram.fbs
@@ -13,192 +13,100 @@
 
 namespace class_metamodel;
 
-/// Visibility modifier for class members
 enum Visibility : byte {
     Public = 0,
     Private = 1,
-    Protected = 2,
-    Package = 3
+    Protected = 2
 }
 
-/// Type of entity in a class diagram
 enum EntityType : byte {
     Class = 0,
     Struct = 1,
     Interface = 2,
-    Enum = 3,
-    AbstractClass = 4,
-    Annotation = 5,
-    Object = 6
+    AbstractClass = 3,
+    Enum = 4
 }
 
-/// Type of container/grouping
-enum ContainerType : byte {
-    Namespace = 0,
-    Package = 1
-}
-
-/// Types of relationships between entities
 enum RelationType : byte {
     Inheritance = 0,
     Implementation = 1,
     Composition = 2,
     Aggregation = 3,
     Association = 4,
-    Dependency = 5,
-    Link = 6,
-    DashedLink = 7
+    Dependency = 5
 }
 
-/// Method parameter
-table Parameter {
-    /// Parameter name
-    name: string;
-    /// Parameter type (e.g., "int", "const char*")
+enum MethodModifier : byte {
+    Static = 0,
+    Virtual = 1,
+    Abstract = 2,
+    Override = 3,
+    Constructor = 4,
+    Destructor = 5,
+    Noexcept = 6
+}
+
+table TypeAlias {
+    alias: string (required);
+    original_type: string (required);
+}
+
+table FunctionArgument {
+    name: string (required);
     param_type: string;
-    /// Default value if any
-    default_value: string;
-    /// Whether passed by reference
-    is_reference: bool = false;
-    /// Whether the parameter is const
-    is_const: bool = false;
-    /// Whether this is a variadic parameter (...)
     is_variadic: bool = false;
 }
 
-/// Class attribute (member variable)
-table Attribute {
-    /// Attribute name
+table MemberVariable {
     name: string (required);
-    /// Data type (e.g., "int", "std::string")
     data_type: string;
-    /// Visibility modifier
     visibility: Visibility = Public;
-    /// Default/initial value
-    default_value: string;
-    /// Whether this is a static member
     is_static: bool = false;
-    /// Whether this is a const member
     is_const: bool = false;
-    /// Description or documentation
-    description: string;
 }
 
-/// Class method (member function)
 table Method {
-    /// Method name
     name: string (required);
-    /// Return type
     return_type: string;
-    /// Visibility modifier
     visibility: Visibility = Public;
-    /// Method parameters
-    parameters: [Parameter];
-    /// Template parameters for generic methods
-    template_params: [string];
-    /// Whether this is a static method
-    is_static: bool = false;
-    /// Whether this is a const method
-    is_const: bool = false;
-    /// Whether this is a virtual method
-    is_virtual: bool = false;
-    /// Whether this is a pure virtual (abstract) method
-    is_abstract: bool = false;
-    /// Whether this is an override
-    is_override: bool = false;
-    /// Whether this is a constructor
-    is_constructor: bool = false;
-    /// Whether this is a destructor
-    is_destructor: bool = false;
+    parameters: [FunctionArgument];
+    template_parameters: [string];
+    modifiers: [MethodModifier];
 }
 
-/// Enum literal/value
 table EnumLiteral {
-    /// Literal name
     name: string (required);
-    /// Visibility (if specified)
-    visibility: Visibility = Public;
-    /// Explicit value (e.g., "0", "1")
     value: string;
-    /// Description/documentation
-    description: string;
 }
 
-/// Entity representing a class, struct, interface, enum, etc.
-table Entity {
-    /// Fully Qualified Name (FQN) - unique identifier
-    id: string (required);
-    /// Display name
-    name: string;
-    /// Short alias for referencing
-    alias: string;
-    /// FQN of parent namespace/package
-    parent_id: string;
-    /// Type of entity
-    entity_type: EntityType = Class;
-    /// Stereotypes applied (e.g., "Model", "Singleton")
-    stereotypes: [string];
-    /// Attributes (member variables)
-    attributes: [Attribute];
-    /// Methods (member functions)
-    methods: [Method];
-    /// Template parameters for generic types
-    template_params: [string];
-    /// Enum literals (only for Enum type)
-    enum_literals: [EnumLiteral];
-    /// Source file location
-    source_file: string;
-    /// 1-based line number in source; 0 means the source line is unknown
-    source_line: uint32;
-}
-
-/// Container representing a namespace or package
-table Container {
-    /// Fully Qualified Name (FQN)
-    id: string (required);
-    /// Display name
-    name: string (required);
-    /// FQN of parent container
-    parent_id: string;
-    /// Type of container
-    container_type: ContainerType = Namespace;
-}
-
-/// Relationship between two entities
 table Relationship {
-    /// FQN of the source entity
     source: string (required);
-    /// FQN of the target entity
     target: string (required);
-    /// Type of relationship
     relation_type: RelationType = Association;
-    /// Label/annotation on the relationship
-    label: string;
-    /// Stereotype on the relationship
-    stereotype: string;
-    /// Source multiplicity (e.g., "1", "0..*")
     source_multiplicity: string;
-    /// Target multiplicity
     target_multiplicity: string;
-    /// Source role name
-    source_role: string;
-    /// Target role name
-    target_role: string;
 }
 
-/// Complete class diagram model
+table SimpleEntity {
+    id: string (required);
+    name: string (required);
+    enclosing_namespace_id: string;
+    entity_type: EntityType = Class;
+    type_aliases: [TypeAlias];
+    variables: [MemberVariable];
+    methods: [Method];
+    template_parameters: [string];
+    enum_literals: [EnumLiteral];
+    relationships: [Relationship];
+    source_file: string;
+    source_line: uint32;
+}
+
 table ClassDiagram {
-    /// Diagram name (usually the source file)
     name: string (required);
-    /// All entities in the diagram
-    entities: [Entity];
-    /// All containers (namespaces/packages)
-    containers: [Container];
-    /// All relationships between entities
+    entities: [SimpleEntity];
     relationships: [Relationship];
-    /// Source files parsed
     source_files: [string];
-    /// Parser/writer version
     version: string;
 }
 
diff --git a/tools/metamodel/src/class_logic.rs b/tools/metamodel/src/class_logic.rs
index 4f88fdf3..c99f4c53 100644
--- a/tools/metamodel/src/class_logic.rs
+++ b/tools/metamodel/src/class_logic.rs
@@ -17,40 +17,59 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
 pub struct ClassDiagram {
     pub name: String,
-    pub entities: Vec<LogicEntity>,
-    pub containers: Vec<LogicContainer>,
-    pub relationships: Vec<LogicRelationship>,
+    pub entities: Vec<SimpleEntity>,
+    // all relationships in the entire diagram
+    pub relationships: Vec<Relationship>, // would make sense inside entities
+
     pub source_files: Vec<String>,
     pub version: Option<String>,
 }
 
 /// Represents a class, struct, interface, enum, or other type entity
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
-pub struct LogicEntity {
+pub struct SimpleEntity {
     /// Fully Qualified Name (FQN) - unique identifier including namespace path
+    // mw::com::test{
+    //     int bla
+    // } -> mw.com.test.bla
+    //
+    //package core::geometry <<subdomain>> {
+    // class Circle <<entity>> {
+    // "id": "core.geometry.Circle",
     pub id: String,
     /// Display name (may differ from id when alias is used)
-    pub name: Option<String>,
-    /// Short alias for referencing (e.g., `class "LongName" as Alias`)
-    pub alias: Option<String>,
+    /// just variable name in c++ and alias in plantuml (if alias does not exist label name is the
+    /// fallback)
+    pub name: String,
+
     /// FQN of parent namespace/package
-    pub parent_id: Option<String>,
+    /// enclosing namespace name
+    pub enclosing_namespace_id: Option<String>,
     /// Type of entity (class, struct, interface, enum, etc.)
     pub entity_type: EntityType,
-    /// Stereotypes applied to this entity (e.g., <<Model>>, <<Singleton>>)
-    pub stereotypes: Vec<String>,
-    /// Attributes (member variables)
-    pub attributes: Vec<LogicAttribute>,
+
+    // aliased type with using keyword also called annotation in plantuml
+    pub type_aliases: Vec<TypeAlias>,
+    pub variables: Vec<MemberVariable>,
     /// Methods (member functions)
-    pub methods: Vec<LogicMethod>,
-    /// Template parameters for generic types
-    pub template_params: Vec<String>,
+    pub methods: Vec<Method>,
+    /// Template parameters for generic types (empty option means not templated) empty vector means
+    /// template is an empty bracket like template<> which can be encountered during explicit template specialization
+    pub template_parameters: Option<Vec<String>>,
+
     /// Enum literals (only for Enum entity_type)
-    pub enum_literals: Vec<LogicEnumLiteral>,
+    pub enum_literals: Vec<EnumLiteral>,
+
+    // all relationships for current entity
+    pub relationships: Vec<Relationship>,
+
+    /// Debug info for display in case of mismatch
+    ///
     /// Source file location
     pub source_file: Option<String>,
     /// 1-based line number in source; `None` means the source line is unknown
     pub source_line: Option<u32>,
+    // pub relstionships: Vec<LogicRelationship>, // relationships where this entity is the source
 }
 
 /// The type of entity in a class diagram
@@ -62,40 +81,14 @@ pub enum EntityType {
     Class,
     /// Data structure (typically POD in C++)
     Struct,
-    /// Object instance node
-    Object,
+
     /// Abstract interface
     Interface,
-    /// Enumeration
-    Enum,
     /// Abstract class
     AbstractClass,
-    /// Annotation type
-    Annotation,
-}
 
-/// The type of container/grouping in a class diagram
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
-#[serde(rename_all = "PascalCase")]
-pub enum ContainerType {
-    /// C++ namespace
-    #[default]
-    Namespace,
-    /// Logical package grouping
-    Package,
-}
-
-/// Represents a namespace or package container
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
-pub struct LogicContainer {
-    /// Fully Qualified Name (FQN)
-    pub id: String,
-    /// Display name
-    pub name: String,
-    /// FQN of parent container
-    pub parent_id: Option<String>,
-    /// Type of container
-    pub container_type: ContainerType,
+    /// Enumeration
+    Enum,
 }
 
 /// Visibility modifier for members
@@ -109,49 +102,90 @@ pub enum Visibility {
     Private,
     /// Protected visibility (#)
     Protected,
-    /// Package-private visibility (~)
-    Package,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct TypeAlias {
+    /// example: using Number = double;
+    /// alias = "Number"
+    /// original_type = "double"
+    pub alias: String,
+    pub original_type: String,
 }
 
 /// Represents a class attribute (member variable)
+/// renamed from LogicAttribute
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
-pub struct LogicAttribute {
+pub struct MemberVariable {
     /// Attribute name
     pub name: String,
     /// Data type (e.g., "int", "string", "std::vector<int>")
     pub data_type: Option<String>,
     /// Visibility modifier
     pub visibility: Visibility,
-    /// Default/initial value
-    pub default_value: Option<String>,
     /// Whether this is a static member
     pub is_static: bool,
     /// Whether this is a const member
     pub is_const: bool,
-    /// Description or documentation
-    pub description: Option<String>,
 }
 
 /// Represents a method parameter
+/// renamed from LogicParameter
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
-pub struct LogicParameter {
+pub struct FunctionArgument {
     /// Parameter name
     pub name: String,
     /// Parameter type
     pub param_type: Option<String>,
-    /// Default value if any
-    pub default_value: Option<String>,
-    /// Whether passed by reference
-    pub is_reference: bool,
-    /// Whether the parameter is const
-    pub is_const: bool,
-    /// Whether this is a variadic parameter (...)
     pub is_variadic: bool,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum MethodModifier {
+    Static,
+    Virtual,
+    Abstract,
+    Override,
+    Constructor,
+    Destructor,
+    Noexcept,
+}
+
+impl MethodModifier {
+    pub fn make_modifier_vec(
+        is_static: bool,
+        is_virtual: bool,
+        is_abstract: bool,
+        is_override: bool,
+        is_constructor: bool,
+        is_destructor: bool,
+    ) -> Vec<MethodModifier> {
+        let mut modifiers = Vec::new();
+        if is_static {
+            modifiers.push(MethodModifier::Static);
+        }
+        if is_virtual {
+            modifiers.push(MethodModifier::Virtual);
+        }
+        if is_abstract {
+            modifiers.push(MethodModifier::Abstract);
+        }
+        if is_override {
+            modifiers.push(MethodModifier::Override);
+        }
+        if is_constructor {
+            modifiers.push(MethodModifier::Constructor);
+        }
+        if is_destructor {
+            modifiers.push(MethodModifier::Destructor);
+        }
+        modifiers
+    }
+}
+
 /// Represents a class method (member function)
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
-pub struct LogicMethod {
+pub struct Method {
     /// Method name
     pub name: String,
     /// Return type
@@ -159,46 +193,28 @@ pub struct LogicMethod {
     /// Visibility modifier
     pub visibility: Visibility,
     /// Method parameters
-    pub parameters: Vec<LogicParameter>,
+    pub parameters: Vec<FunctionArgument>,
     /// Template parameters for generic methods
-    pub template_params: Vec<String>,
-    /// Whether this is a static method
-    pub is_static: bool,
-    /// Whether this is a const method
-    pub is_const: bool,
-    /// Whether this is a virtual method
-    pub is_virtual: bool,
-    /// Whether this is a pure virtual (abstract) method
-    pub is_abstract: bool,
-    /// Whether this is an override
-    pub is_override: bool,
-    /// Whether this is a constructor
-    pub is_constructor: bool,
-    /// Whether this is a destructor
-    pub is_destructor: bool,
+    pub template_parameters: Option<Vec<String>>,
+    pub modifiers: Vec<MethodModifier>,
 }
 
 /// Represents a relationship between two entities
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
-pub struct LogicRelationship {
+pub struct Relationship {
     /// FQN of the source entity
     pub source: String,
     /// FQN of the target entity
     pub target: String,
     /// Type of relationship
     pub relation_type: RelationType,
-    /// Label/annotation on the relationship
-    pub label: Option<String>,
-    /// Stereotype on the relationship (e.g., <<DependsOn>>)
-    pub stereotype: Option<String>,
+
+    // NOTE:  these might not be used for validation
+    //
     /// Source multiplicity (e.g., "1", "0..*", "1..n")
     pub source_multiplicity: Option<String>,
     /// Target multiplicity
     pub target_multiplicity: Option<String>,
-    /// Source role name
-    pub source_role: Option<String>,
-    /// Target role name
-    pub target_role: Option<String>,
 }
 
 /// Types of relationships in class diagrams
@@ -214,56 +230,19 @@ pub enum RelationType {
     Composition,
     /// Aggregation (weak ownership) - `o--`
     Aggregation,
-    /// Directed association - `-->`
+    /// Directed association - `-->` (depends on  A --> B means A depends on B)
     Association,
     /// Dependency (uses) - `..>`
     Dependency,
-    /// Simple link - `--`
-    Link,
-    /// Dashed link - `..`
-    DashedLink,
 }
 
 /// Represents an enum literal/value
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
-pub struct LogicEnumLiteral {
+pub struct EnumLiteral {
     /// Literal name
     pub name: String,
-    /// Visibility (if specified)
-    pub visibility: Visibility,
     /// Explicit value (e.g., `HIGH = 0`)
     pub value: Option<String>,
-    /// Description/documentation
-    pub description: Option<String>,
-}
-
-/// Error types for class diagram resolution
-#[derive(Debug, thiserror::Error)]
-pub enum ClassResolverError {
-    #[error("Class Resolver: Unresolved reference: {reference}")]
-    UnresolvedReference { reference: String },
-
-    #[error("Duplicate entity id: {entity_id}")]
-    DuplicateEntity { entity_id: String },
-
-    #[error("Unknown entity type: {entity_type}")]
-    UnknownEntityType { entity_type: String },
-
-    #[error("Invalid relationship: {from} -> {to}: {reason}")]
-    InvalidRelationship {
-        from: String,
-        to: String,
-        reason: String,
-    },
-
-    #[error("Circular inheritance detected: {cycle}")]
-    CircularInheritance { cycle: String },
-
-    #[error("Invalid visibility modifier: {modifier}")]
-    InvalidVisibility { modifier: String },
-
-    #[error("Parse error: {message}")]
-    ParseError { message: String },
 }
 
 #[cfg(test)]
@@ -272,59 +251,47 @@ mod tests {
 
     #[test]
     fn test_entity_serialization() {
-        let entity = LogicEntity {
+        let entity = SimpleEntity {
             id: "Core::User".to_string(),
-            name: Some("User".to_string()),
-            alias: None,
-            parent_id: Some("Core".to_string()),
+            name: "User".to_string(),
+            enclosing_namespace_id: Some("Core".to_string()),
             entity_type: EntityType::Class,
-            stereotypes: vec!["Model".to_string()],
-            attributes: vec![LogicAttribute {
+            variables: vec![MemberVariable {
                 name: "name".to_string(),
                 data_type: Some("string".to_string()),
                 visibility: Visibility::Public,
-                default_value: None,
                 is_static: false,
                 is_const: false,
-                description: None,
             }],
-            methods: vec![LogicMethod {
+            methods: vec![Method {
                 name: "getName".to_string(),
                 return_type: Some("string".to_string()),
                 visibility: Visibility::Public,
                 parameters: vec![],
-                template_params: vec![],
-                is_static: false,
-                is_const: true,
-                is_virtual: false,
-                is_abstract: false,
-                is_override: false,
-                is_constructor: false,
-                is_destructor: false,
+                template_parameters: None,
+                modifiers: vec![MethodModifier::Virtual],
             }],
-            template_params: vec![],
+            template_parameters: None,
             enum_literals: vec![],
             source_file: None,
             source_line: None,
+            type_aliases: vec![],
+            relationships: vec![],
         };
 
         let json = serde_json::to_string_pretty(&entity).unwrap();
-        let deserialized: LogicEntity = serde_json::from_str(&json).unwrap();
+        let deserialized: SimpleEntity = serde_json::from_str(&json).unwrap();
         assert_eq!(entity, deserialized);
     }
 
     #[test]
     fn test_relationship_types() {
-        let inheritance = LogicRelationship {
+        let inheritance = Relationship {
             source: "Derived".to_string(),
             target: "Base".to_string(),
             relation_type: RelationType::Inheritance,
-            label: None,
-            stereotype: None,
             source_multiplicity: None,
             target_multiplicity: None,
-            source_role: None,
-            target_role: None,
         };
 
         assert_eq!(inheritance.relation_type, RelationType::Inheritance);
@@ -333,33 +300,23 @@ mod tests {
     #[test]
     fn test_partial_plantuml_entity() {
         // PlantUML often has incomplete information - this should still work
-        let entity = LogicEntity {
+        let entity = SimpleEntity {
             id: "UserService".to_string(),
-            name: Some("UserService".to_string()),
+            name: "UserService".to_string(),
             entity_type: EntityType::Class,
-            stereotypes: vec!["service".to_string()],
-            // No attributes specified (common in high-level diagrams)
-            attributes: vec![],
-            // Method with no return type (PlantUML allows this)
-            methods: vec![LogicMethod {
+            methods: vec![Method {
                 name: "getUser".to_string(),
-                return_type: None, // <-- Often omitted in PlantUML
+                return_type: None,
                 visibility: Visibility::Public,
                 parameters: vec![],
-                template_params: vec![],
-                is_static: false,
-                is_const: false,
-                is_virtual: false,
-                is_abstract: false,
-                is_override: false,
-                is_constructor: false,
-                is_destructor: false,
+                template_parameters: None,
+                modifiers: vec![],
             }],
             ..Default::default()
         };
 
         let json = serde_json::to_string(&entity).unwrap();
-        let deserialized: LogicEntity = serde_json::from_str(&json).unwrap();
+        let deserialized: SimpleEntity = serde_json::from_str(&json).unwrap();
         assert_eq!(entity, deserialized);
         assert!(entity.methods[0].return_type.is_none());
     }