diff --git a/cpp/libclang/integration_test/cases/template_class/expected.json b/cpp/libclang/integration_test/cases/template_class/expected.json
index 60c65246..b8cb34bb 100644
--- a/cpp/libclang/integration_test/cases/template_class/expected.json
+++ b/cpp/libclang/integration_test/cases/template_class/expected.json
@@ -1,5 +1,43 @@
 {
   "types": {
+    "ContainerOwner": {
+      "id": "ContainerOwner",
+      "name": "ContainerOwner",
+      "enclosing_namespace_id": null,
+      "entity_type": "Class",
+      "enum_literals": [],
+      "methods": [
+        {
+          "name": "values",
+          "return_type": "Container<int>",
+          "parameters": [],
+          "modifiers": [],
+          "template_parameters": null,
+          "visibility": "public"
+        }
+      ],
+      "relationships": [],
+      "template_parameters": [
+        {
+          "Template": {
+            "name": "Container",
+            "parameters": [
+              {
+                "Type": {
+                  "name": "T0",
+                  "is_pack": false
+                }
+              }
+            ],
+            "is_pack": false
+          }
+        }
+      ],
+      "type_aliases": [],
+      "variables": [],
+      "source_file": "cpp/libclang/integration_test/cases/template_class/transport.cpp",
+      "source_line": 36
+    },
     "FixedBuffer": {
       "id": "FixedBuffer",
       "name": "FixedBuffer",
@@ -32,10 +70,43 @@
         {
           "name": "convert",
           "return_type": "U",
-          "parameters": [],
+          "parameters": [
+            {
+              "name": "input",
+              "param_type": "const T &",
+              "is_variadic": false
+            }
+          ],
           "modifiers": [],
           "template_parameters": [
-            "U"
+            {
+              "Type": {
+                "name": "U",
+                "is_pack": false
+              }
+            }
+          ],
+          "visibility": "public"
+        },
+        {
+          "name": "emplace",
+          "return_type": "void",
+          "parameters": [
+            {
+              "name": "args",
+              "param_type": "Args &&",
+              "is_variadic": false,
+              "is_pack_expansion": true
+            }
+          ],
+          "modifiers": [],
+          "template_parameters": [
+            {
+              "Type": {
+                "name": "Args",
+                "is_pack": true
+              }
+            }
           ],
           "visibility": "public"
         },
@@ -50,9 +121,25 @@
       ],
       "relationships": [],
       "template_parameters": [
-        "T",
-        "int N",
-        "T2"
+        {
+          "Type": {
+            "name": "T",
+            "is_pack": false
+          }
+        },
+        {
+          "NonType": {
+            "name": "N",
+            "value_type": "int",
+            "is_pack": false
+          }
+        },
+        {
+          "Type": {
+            "name": "T2",
+            "is_pack": false
+          }
+        }
       ],
       "type_aliases": [],
       "variables": [
diff --git a/cpp/libclang/integration_test/cases/template_class/transport.cpp b/cpp/libclang/integration_test/cases/template_class/transport.cpp
index 2c99b70d..7f95311a 100644
--- a/cpp/libclang/integration_test/cases/template_class/transport.cpp
+++ b/cpp/libclang/integration_test/cases/template_class/transport.cpp
@@ -22,9 +22,19 @@ class FixedBuffer
     template <typename U>
     U convert(const T& input) const;
 
+    template <typename... Args>
+    void emplace(Args&&... args);
+
     int capacity() const;
 
   private:
     T m_data[N];
     int m_size;
 };
+
+template <template <typename> class Container>
+class ContainerOwner
+{
+  public:
+    Container<int> values();
+};
diff --git a/cpp/libclang/src/visitor/src/class_parser_helper.rs b/cpp/libclang/src/visitor/src/class_parser_helper.rs
index 322e4942..98ee215d 100644
--- a/cpp/libclang/src/visitor/src/class_parser_helper.rs
+++ b/cpp/libclang/src/visitor/src/class_parser_helper.rs
@@ -586,6 +586,10 @@ fn unknown(ty: &Type) -> ResolvedType {
 }
 
 fn build_entity_id_from_decl(entity: &Entity) -> String {
+    if entity.get_kind() == EntityKind::TemplateTemplateParameter {
+        return entity.get_name().unwrap_or_default();
+    }
+
     strip_global_scope_prefix(&build_fqn_from_entity(entity))
 }
 
@@ -640,6 +644,7 @@ fn build_fqn_from_entity(entity: &Entity) -> String {
             | EntityKind::UnionDecl
             | EntityKind::EnumDecl
             | EntityKind::ClassTemplate
+            | EntityKind::TemplateTemplateParameter
             | EntityKind::TypedefDecl
             | EntityKind::TypeAliasDecl => {
                 if let Some(name) = entity.get_name() {
diff --git a/cpp/libclang/src/visitor/src/class_visitor.rs b/cpp/libclang/src/visitor/src/class_visitor.rs
index 3ea81286..72f6c012 100644
--- a/cpp/libclang/src/visitor/src/class_visitor.rs
+++ b/cpp/libclang/src/visitor/src/class_visitor.rs
@@ -15,7 +15,7 @@ use std::collections::HashSet;
 
 use class_diagram::{
     EntityType, FunctionArgument, MemberVariable, Method, MethodModifier, RelationType,
-    Relationship, SimpleEntity, TypeAlias, Visibility,
+    Relationship, SimpleEntity, TemplateParameter, TypeAlias, Visibility,
 };
 
 use crate::class_parser_helper::{
@@ -169,9 +169,7 @@ fn collect_method_type(entity: &Entity, builder: &mut ParsedClassInfo) -> Parsed
         .get_result_type()
         .map(|t| resolve_type(&t))
         .unwrap_or_else(|| ResolvedType::Builtin("void".to_string()));
-    let parameter_types = entity
-        .get_arguments()
-        .unwrap_or_default()
+    let parameter_types = method_arguments(entity)
         .into_iter()
         .filter_map(|arg| arg.get_type().map(|t| resolve_type(&t)))
         .collect();
@@ -186,6 +184,22 @@ fn collect_method_type(entity: &Entity, builder: &mut ParsedClassInfo) -> Parsed
     parsed_method_type
 }
 
+/// Normally libclang provides the parameter list via `Entity::get_arguments()`.
+/// However, for some cursor kinds (e.g. `FunctionTemplate`) or certain libclang
+/// versions, `get_arguments()` may return `None` even though the AST still
+/// contains `ParmDecl` child cursors.
+fn method_arguments<'tu>(entity: &Entity<'tu>) -> Vec<Entity<'tu>> {
+    entity.get_arguments().unwrap_or_else(|| {
+        // fall back to collecting all direct `ParmDecl` children from
+        // the cursor to recover the parameter list.
+        entity
+            .get_children()
+            .into_iter()
+            .filter(|child| child.get_kind() == EntityKind::ParmDecl)
+            .collect()
+    })
+}
+
 fn parse_type_alias(entity: &Entity) -> Option<TypeAlias> {
     let alias = entity.get_name()?;
 
@@ -218,20 +232,23 @@ fn parse_method(entity: &Entity, parsed_method_type: &ParsedMethodType) -> Optio
     let mut parameters = Vec::new();
     let method_is_variadic = entity.get_type().map(|t| t.is_variadic()).unwrap_or(false);
 
-    if let Some(args) = entity.get_arguments() {
-        let arg_count = args.len();
-        for (idx, arg) in args.into_iter().enumerate() {
-            let param_type = arg
-                .get_type()
-                .map(|ty| ty.get_display_name())
-                .unwrap_or_default();
-
-            parameters.push(FunctionArgument {
-                name: arg.get_name().unwrap_or_default(),
-                param_type: Some(param_type),
-                is_variadic: method_is_variadic && idx + 1 == arg_count,
-            });
-        }
+    let args = method_arguments(entity);
+
+    let arg_count = args.len();
+    for (idx, arg) in args.into_iter().enumerate() {
+        let raw_param_type = arg
+            .get_type()
+            .map(|ty| ty.get_display_name())
+            .unwrap_or_default();
+        let is_pack_expansion = raw_param_type.contains("...");
+        let param_type = normalize_pack_expansion_type(&raw_param_type);
+
+        parameters.push(FunctionArgument {
+            name: arg.get_name().unwrap_or_default(),
+            param_type: Some(param_type),
+            is_variadic: method_is_variadic && idx + 1 == arg_count,
+            is_pack_expansion,
+        });
     }
 
     Some(Method {
@@ -265,32 +282,47 @@ fn parse_variable(
     })
 }
 
-fn parse_template_parameters(entity: &Entity) -> Option<Vec<String>> {
-    let params: Vec<String> = entity
+fn parse_template_parameters(entity: &Entity) -> Option<Vec<TemplateParameter>> {
+    let params: Vec<TemplateParameter> = entity
         .get_children()
         .into_iter()
         .enumerate()
         .filter_map(|(idx, child)| match child.get_kind() {
             EntityKind::TemplateTypeParameter => {
-                // template <typename Foo>  →  "Foo"
-                // template <typename, typename> -> "T0", "T1"
-                Some(child.get_name().unwrap_or_else(|| format!("T{idx}")))
+                // template <typename Foo>  →  "name: Foo, is_pack: False"
+                // template <typename, typename> -> "name: T0, is_pack: False", "name: T1, is_pack: False"
+                // template <typename... Foo> -> "name: Foo, is_pack: True"
+                let name = child.get_name().unwrap_or_else(|| format!("T{idx}"));
+
+                Some(TemplateParameter::Type {
+                    name,
+                    is_pack: is_template_parameter_pack(&child),
+                })
             }
             EntityKind::NonTypeTemplateParameter => {
-                // template <int N>  →  "int N"
+                // template <int N>  →  "name: N, value_type: int"
                 let type_name = child
                     .get_type()
                     .map(|t| t.get_display_name())
                     .unwrap_or_default();
                 let name = child.get_name().unwrap_or_default();
-                Some(format!("{type_name} {name}").trim().to_string())
+
+                Some(TemplateParameter::NonType {
+                    name,
+                    value_type: type_name,
+                    is_pack: is_template_parameter_pack(&child),
+                })
             }
             EntityKind::TemplateTemplateParameter => {
-                // template <template<...> class C>  →  "template<...> C"
-                Some(format!(
-                    "template<...> {}",
-                    child.get_name().unwrap_or_default()
-                ))
+                // template <template<...> class C>  → "name: C, parameters: [...], is_pack: False"
+                let parameters = parse_template_parameters(&child).unwrap_or_default();
+                let name = child.get_name().unwrap_or_else(|| format!("T{idx}"));
+
+                Some(TemplateParameter::Template {
+                    name,
+                    parameters,
+                    is_pack: is_template_parameter_pack(&child),
+                })
             }
             _ => None,
         })
@@ -303,6 +335,22 @@ fn parse_template_parameters(entity: &Entity) -> Option<Vec<String>> {
     }
 }
 
+fn normalize_pack_expansion_type(param_type: &str) -> String {
+    param_type.replace("...", "").trim().to_string()
+}
+
+fn is_template_parameter_pack(entity: &Entity) -> bool {
+    entity.get_range().is_some_and(|range| {
+        range
+            .tokenize()
+            .iter()
+            .any(|token| token.get_spelling() == "...")
+    }) || entity
+        .get_display_name()
+        .as_deref()
+        .is_some_and(|display_name| display_name.contains("..."))
+}
+
 fn parse_visibility(entity: &Entity) -> Visibility {
     match entity.get_accessibility() {
         Some(clang::Accessibility::Public) => Visibility::Public,
diff --git a/plantuml/parser/integration_test/class_diagram/class_diagram_cpp_members/output.json b/plantuml/parser/integration_test/class_diagram/class_diagram_cpp_members/output.json
index 31a6ee80..b92e2ef3 100644
--- a/plantuml/parser/integration_test/class_diagram/class_diagram_cpp_members/output.json
+++ b/plantuml/parser/integration_test/class_diagram/class_diagram_cpp_members/output.json
@@ -50,8 +50,18 @@
               }
             ],
             "template_parameters": [
-              "CallableType",
-              "ArgumentTypes..."
+              {
+                "Type": {
+                  "name": "CallableType",
+                  "is_pack": false
+                }
+              },
+              {
+                "Type": {
+                  "name": "ArgumentTypes",
+                  "is_pack": true
+                }
+              }
             ],
             "modifiers": []
           },
@@ -72,7 +82,12 @@
               }
             ],
             "template_parameters": [
-              "T"
+              {
+                "Type": {
+                  "name": "T",
+                  "is_pack": false
+                }
+              }
             ],
             "modifiers": []
           },
diff --git a/plantuml/parser/integration_test/class_diagram/class_diagram_file_level_constructs/output.json b/plantuml/parser/integration_test/class_diagram/class_diagram_file_level_constructs/output.json
index fa0b3735..caab94a1 100644
--- a/plantuml/parser/integration_test/class_diagram/class_diagram_file_level_constructs/output.json
+++ b/plantuml/parser/integration_test/class_diagram/class_diagram_file_level_constructs/output.json
@@ -76,7 +76,12 @@
           }
         ],
         "template_parameters": [
-          "T"
+          {
+            "Type": {
+              "name": "T",
+              "is_pack": false
+            }
+          }
         ],
         "enum_literals": [],
         "source_file": "class_diagram_file_level_constructs.puml",
diff --git a/plantuml/parser/integration_test/class_diagram/class_diagram_syntax_coverage/output.json b/plantuml/parser/integration_test/class_diagram/class_diagram_syntax_coverage/output.json
index 9263f888..6f41edc3 100644
--- a/plantuml/parser/integration_test/class_diagram/class_diagram_syntax_coverage/output.json
+++ b/plantuml/parser/integration_test/class_diagram/class_diagram_syntax_coverage/output.json
@@ -257,7 +257,12 @@
         "type_aliases": [],
         "methods": [],
         "template_parameters": [
-          "T"
+          {
+            "Type": {
+              "name": "T",
+              "is_pack": false
+            }
+          }
         ],
         "enum_literals": [],
         "source_file": "class_diagram_syntax_coverage.puml",
@@ -285,11 +290,23 @@
               {
                 "name": "",
                 "param_type": "DiagnosticJobConstructorArgumentTypes",
-                "is_variadic": true
+                "is_variadic": false,
+                "is_pack_expansion": true
               }
             ],
             "template_parameters": [
-              "DiagnosticJobType"
+              {
+                "Type": {
+                  "name": "DiagnosticJobType",
+                  "is_pack": false
+                }
+              },
+              {
+                "Type": {
+                  "name": "DiagnosticJobConstructorArgumentTypes",
+                  "is_pack": true
+                }
+              }
             ],
             "modifiers": []
           }
@@ -440,8 +457,18 @@
               }
             ],
             "template_parameters": [
-              "CallableType",
-              "ArgumentTypes..."
+              {
+                "Type": {
+                  "name": "CallableType",
+                  "is_pack": false
+                }
+              },
+              {
+                "Type": {
+                  "name": "ArgumentTypes",
+                  "is_pack": true
+                }
+              }
             ],
             "modifiers": []
           },
@@ -462,7 +489,12 @@
               }
             ],
             "template_parameters": [
-              "T"
+              {
+                "Type": {
+                  "name": "T",
+                  "is_pack": false
+                }
+              }
             ],
             "modifiers": []
           },
@@ -628,7 +660,12 @@
           }
         ],
         "template_parameters": [
-          "T"
+          {
+            "Type": {
+              "name": "T",
+              "is_pack": false
+            }
+          }
         ],
         "enum_literals": [],
         "source_file": "class_diagram_syntax_coverage.puml",
diff --git a/plantuml/parser/integration_test/class_diagram/class_template_pack/class_template_pack.puml b/plantuml/parser/integration_test/class_diagram/class_template_pack/class_template_pack.puml
new file mode 100644
index 00000000..e4aef216
--- /dev/null
+++ b/plantuml/parser/integration_test/class_diagram/class_template_pack/class_template_pack.puml
@@ -0,0 +1,35 @@
+' *******************************************************************************
+' Copyright (c) 2026 Contributors to the Eclipse Foundation
+'
+' See the NOTICE file(s) distributed with this work for additional
+' information regarding copyright ownership.
+'
+' This program and the accompanying materials are made available under the
+' terms of the Apache License Version 2.0 which is available at
+' https://www.apache.org/licenses/LICENSE-2.0
+'
+' SPDX-License-Identifier: Apache-2.0
+' *******************************************************************************
+@startuml class_template_pack
+
+class ExplicitClassTemplatePack1<OutArgs, InArgs...> {
+    + Invoke(args: InArgs...)
+}
+
+class ExplicitClassTemplatePack2<OutArgs, InArgs...> {
+    + Invoke(args: InArgs&&...)
+}
+
+class ImplicitClassTemplatePack1<OutArgs> {
+    + Invoke(args: InArgs...)
+}
+
+class ImplicitClassTemplatePack2<OutArgs> {
+    + Invoke(args: InArgs&&...)
+}
+
+' class ClassTemplatePackExample<OutArgs, InArgs...> {
+'     + RegisterCallHandler(handler: std::function<OutArgs(InArgs...)>): Result<void>
+' }
+
+@enduml
diff --git a/plantuml/parser/integration_test/class_diagram/class_template_pack/output.json b/plantuml/parser/integration_test/class_diagram/class_template_pack/output.json
new file mode 100644
index 00000000..892e0f8f
--- /dev/null
+++ b/plantuml/parser/integration_test/class_diagram/class_template_pack/output.json
@@ -0,0 +1,184 @@
+{
+  "class_template_pack.puml": {
+    "name": "class_template_pack",
+    "entities": [
+      {
+        "id": "ExplicitClassTemplatePack1",
+        "name": "ExplicitClassTemplatePack1",
+        "enclosing_namespace_id": null,
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "Invoke",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [
+              {
+                "name": "args",
+                "param_type": "InArgs",
+                "is_variadic": false,
+                "is_pack_expansion": true
+              }
+            ],
+            "template_parameters": null,
+            "modifiers": []
+          }
+        ],
+        "template_parameters": [
+          {
+            "Type": {
+              "name": "OutArgs",
+              "is_pack": false
+            }
+          },
+          {
+            "Type": {
+              "name": "InArgs",
+              "is_pack": true
+            }
+          }
+        ],
+        "enum_literals": [],
+        "source_file": "class_template_pack.puml",
+        "source_line": 15,
+        "variables": [],
+        "relationships": []
+      },
+      {
+        "id": "ExplicitClassTemplatePack2",
+        "name": "ExplicitClassTemplatePack2",
+        "enclosing_namespace_id": null,
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "Invoke",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [
+              {
+                "name": "args",
+                "param_type": "InArgs&&",
+                "is_variadic": false,
+                "is_pack_expansion": true
+              }
+            ],
+            "template_parameters": null,
+            "modifiers": []
+          }
+        ],
+        "template_parameters": [
+          {
+            "Type": {
+              "name": "OutArgs",
+              "is_pack": false
+            }
+          },
+          {
+            "Type": {
+              "name": "InArgs",
+              "is_pack": true
+            }
+          }
+        ],
+        "enum_literals": [],
+        "source_file": "class_template_pack.puml",
+        "source_line": 19,
+        "variables": [],
+        "relationships": []
+      },
+      {
+        "id": "ImplicitClassTemplatePack1",
+        "name": "ImplicitClassTemplatePack1",
+        "enclosing_namespace_id": null,
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "Invoke",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [
+              {
+                "name": "args",
+                "param_type": "InArgs",
+                "is_variadic": false,
+                "is_pack_expansion": true
+              }
+            ],
+            "template_parameters": null,
+            "modifiers": []
+          }
+        ],
+        "template_parameters": [
+          {
+            "Type": {
+              "name": "OutArgs",
+              "is_pack": false
+            }
+          },
+          {
+            "Type": {
+              "name": "InArgs",
+              "is_pack": true
+            }
+          }
+        ],
+        "enum_literals": [],
+        "source_file": "class_template_pack.puml",
+        "source_line": 23,
+        "variables": [],
+        "relationships": []
+      },
+      {
+        "id": "ImplicitClassTemplatePack2",
+        "name": "ImplicitClassTemplatePack2",
+        "enclosing_namespace_id": null,
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "Invoke",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [
+              {
+                "name": "args",
+                "param_type": "InArgs&&",
+                "is_variadic": false,
+                "is_pack_expansion": true
+              }
+            ],
+            "template_parameters": null,
+            "modifiers": []
+          }
+        ],
+        "template_parameters": [
+          {
+            "Type": {
+              "name": "OutArgs",
+              "is_pack": false
+            }
+          },
+          {
+            "Type": {
+              "name": "InArgs",
+              "is_pack": true
+            }
+          }
+        ],
+        "enum_literals": [],
+        "source_file": "class_template_pack.puml",
+        "source_line": 27,
+        "variables": [],
+        "relationships": []
+      }
+    ],
+    "relationships": [],
+    "source_files": [
+      "class_template_pack.puml"
+    ],
+    "version": null
+  }
+}
diff --git a/plantuml/parser/integration_test/class_diagram/method_template_pack/method_template_pack.puml b/plantuml/parser/integration_test/class_diagram/method_template_pack/method_template_pack.puml
new file mode 100644
index 00000000..dec163fa
--- /dev/null
+++ b/plantuml/parser/integration_test/class_diagram/method_template_pack/method_template_pack.puml
@@ -0,0 +1,31 @@
+' *******************************************************************************
+' Copyright (c) 2026 Contributors to the Eclipse Foundation
+'
+' See the NOTICE file(s) distributed with this work for additional
+' information regarding copyright ownership.
+'
+' This program and the accompanying materials are made available under the
+' terms of the Apache License Version 2.0 which is available at
+' https://www.apache.org/licenses/LICENSE-2.0
+'
+' SPDX-License-Identifier: Apache-2.0
+' *******************************************************************************
+@startuml method_template_pack
+
+class ExplicitMethodTemplatePack1 {
+    + Create<ValueType, ArgumentTypes...>(ValueType, ArgumentTypes&&...)
+}
+
+class ExplicitMethodTemplatePack2 {
+    + Create<ValueType, ArgumentTypes...>(ValueType, ArgumentTypes...)
+}
+
+class ImplicitMethodTemplatePack1 {
+    + Create<ValueType>(ValueType, ArgumentTypes&&...)
+}
+
+class ImplicitMethodTemplatePack2 {
+    + Create<ValueType>(ValueType, ArgumentTypes...)
+}
+
+@enduml
diff --git a/plantuml/parser/integration_test/class_diagram/method_template_pack/output.json b/plantuml/parser/integration_test/class_diagram/method_template_pack/output.json
new file mode 100644
index 00000000..d291c3a5
--- /dev/null
+++ b/plantuml/parser/integration_test/class_diagram/method_template_pack/output.json
@@ -0,0 +1,208 @@
+{
+  "method_template_pack.puml": {
+    "name": "method_template_pack",
+    "entities": [
+      {
+        "id": "ExplicitMethodTemplatePack1",
+        "name": "ExplicitMethodTemplatePack1",
+        "enclosing_namespace_id": null,
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "Create",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [
+              {
+                "name": "",
+                "param_type": "ValueType",
+                "is_variadic": false,
+                "is_pack_expansion": false
+              },
+              {
+                "name": "",
+                "param_type": "ArgumentTypes&&",
+                "is_variadic": false,
+                "is_pack_expansion": true
+              }
+            ],
+            "template_parameters": [
+              {
+                "Type": {
+                  "name": "ValueType",
+                  "is_pack": false
+                }
+              },
+              {
+                "Type": {
+                  "name": "ArgumentTypes",
+                  "is_pack": true
+                }
+              }
+            ],
+            "modifiers": []
+          }
+        ],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "method_template_pack.puml",
+        "source_line": 15,
+        "variables": [],
+        "relationships": []
+      },
+      {
+        "id": "ExplicitMethodTemplatePack2",
+        "name": "ExplicitMethodTemplatePack2",
+        "enclosing_namespace_id": null,
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "Create",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [
+              {
+                "name": "",
+                "param_type": "ValueType",
+                "is_variadic": false,
+                "is_pack_expansion": false
+              },
+              {
+                "name": "",
+                "param_type": "ArgumentTypes",
+                "is_variadic": false,
+                "is_pack_expansion": true
+              }
+            ],
+            "template_parameters": [
+              {
+                "Type": {
+                  "name": "ValueType",
+                  "is_pack": false
+                }
+              },
+              {
+                "Type": {
+                  "name": "ArgumentTypes",
+                  "is_pack": true
+                }
+              }
+            ],
+            "modifiers": []
+          }
+        ],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "method_template_pack.puml",
+        "source_line": 19,
+        "variables": [],
+        "relationships": []
+      },
+      {
+        "id": "ImplicitMethodTemplatePack1",
+        "name": "ImplicitMethodTemplatePack1",
+        "enclosing_namespace_id": null,
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "Create",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [
+              {
+                "name": "",
+                "param_type": "ValueType",
+                "is_variadic": false,
+                "is_pack_expansion": false
+              },
+              {
+                "name": "",
+                "param_type": "ArgumentTypes&&",
+                "is_variadic": false,
+                "is_pack_expansion": true
+              }
+            ],
+            "template_parameters": [
+              {
+                "Type": {
+                  "name": "ValueType",
+                  "is_pack": false
+                }
+              },
+              {
+                "Type": {
+                  "name": "ArgumentTypes",
+                  "is_pack": true
+                }
+              }
+            ],
+            "modifiers": []
+          }
+        ],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "method_template_pack.puml",
+        "source_line": 23,
+        "variables": [],
+        "relationships": []
+      },
+      {
+        "id": "ImplicitMethodTemplatePack2",
+        "name": "ImplicitMethodTemplatePack2",
+        "enclosing_namespace_id": null,
+        "entity_type": "Class",
+        "type_aliases": [],
+        "methods": [
+          {
+            "name": "Create",
+            "return_type": null,
+            "visibility": "public",
+            "parameters": [
+              {
+                "name": "",
+                "param_type": "ValueType",
+                "is_variadic": false,
+                "is_pack_expansion": false
+              },
+              {
+                "name": "",
+                "param_type": "ArgumentTypes",
+                "is_variadic": false,
+                "is_pack_expansion": true
+              }
+            ],
+            "template_parameters": [
+              {
+                "Type": {
+                  "name": "ValueType",
+                  "is_pack": false
+                }
+              },
+              {
+                "Type": {
+                  "name": "ArgumentTypes",
+                  "is_pack": true
+                }
+              }
+            ],
+            "modifiers": []
+          }
+        ],
+        "template_parameters": null,
+        "enum_literals": [],
+        "source_file": "method_template_pack.puml",
+        "source_line": 27,
+        "variables": [],
+        "relationships": []
+      }
+    ],
+    "relationships": [],
+    "source_files": [
+      "method_template_pack.puml"
+    ],
+    "version": 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 7ca7a720..1f3c87fa 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
@@ -449,6 +449,9 @@ impl ClassResolver {
 
         let id = self.build_fqn(&name.internal, &parent);
 
+        let template_parameters =
+            Self::convert_class_template_parameters(template_parameters, methods);
+
         let entity = SimpleEntity {
             id: id.clone(),
             name: Self::entity_name(name),
@@ -460,7 +463,7 @@ impl ClassResolver {
                 .iter()
                 .map(|method| Self::convert_method(method, &name.internal))
                 .collect(),
-            template_parameters: template_parameters.clone(),
+            template_parameters,
             enum_literals: vec![],
             relationships: vec![],
             source_file: self.current_source_file(),
@@ -508,7 +511,10 @@ impl ClassResolver {
             return_type: m.r#type.clone(),
             visibility: Self::map_visibility(m.visibility.clone()),
             parameters: m.params.iter().map(Self::convert_param).collect(),
-            template_parameters: m.template_parameters.clone(),
+            template_parameters: Self::convert_template_parameters_with_pack_expansions(
+                &m.template_parameters,
+                &m.params,
+            ),
             modifiers: MethodModifier::from_conditions([
                 (has_modifier(&m.modifiers, "static"), MethodModifier::Static),
                 (false, MethodModifier::Virtual),
@@ -532,11 +538,95 @@ impl ClassResolver {
             .trim()
     }
 
+    fn convert_template_parameters(
+        parameters: &Option<Vec<String>>,
+    ) -> Option<Vec<TemplateParameter>> {
+        parameters.as_ref().map(|values| {
+            values
+                .iter()
+                .map(|value| {
+                    let trimmed = value.trim();
+                    let (name, is_pack) = trimmed
+                        .strip_suffix("...")
+                        .map(|name| (name.trim(), true))
+                        .unwrap_or((trimmed, false));
+
+                    TemplateParameter::Type {
+                        name: name.to_string(),
+                        is_pack,
+                    }
+                })
+                .collect()
+        })
+    }
+
+    fn convert_class_template_parameters(
+        parameters: &Option<Vec<String>>,
+        methods: &[ParserMethod],
+    ) -> Option<Vec<TemplateParameter>> {
+        parameters.as_ref()?;
+
+        let mut converted = Self::convert_template_parameters(parameters).unwrap_or_default();
+
+        for method in methods {
+            Self::append_pack_expansion_parameters(&mut converted, &method.params);
+        }
+
+        (!converted.is_empty()).then_some(converted)
+    }
+
+    fn convert_template_parameters_with_pack_expansions(
+        parameters: &Option<Vec<String>>,
+        params: &[ParserParam],
+    ) -> Option<Vec<TemplateParameter>> {
+        parameters.as_ref()?;
+
+        let mut converted = Self::convert_template_parameters(parameters).unwrap_or_default();
+        Self::append_pack_expansion_parameters(&mut converted, params);
+
+        (!converted.is_empty()).then_some(converted)
+    }
+
+    fn append_pack_expansion_parameters(
+        template_parameters: &mut Vec<TemplateParameter>,
+        params: &[ParserParam],
+    ) {
+        for param in params.iter().filter(|param| param.varargs) {
+            let Some(pack_name) = param
+                .param_type
+                .as_deref()
+                .and_then(Self::infer_pack_name_from_param_type)
+            else {
+                continue;
+            };
+
+            if !template_parameters
+                .iter()
+                .any(|parameter| parameter.name() == pack_name)
+            {
+                template_parameters.push(TemplateParameter::Type {
+                    name: pack_name.to_string(),
+                    is_pack: true,
+                });
+            }
+        }
+    }
+
+    fn infer_pack_name_from_param_type(param_type: &str) -> Option<&str> {
+        let trimmed = param_type.trim();
+        let candidate = trimmed.strip_suffix("&&").unwrap_or(trimmed).trim();
+
+        (!candidate.is_empty()).then_some(candidate)
+    }
+
     fn convert_param(param: &ParserParam) -> FunctionArgument {
         FunctionArgument {
             name: param.name.clone().unwrap_or_default(),
             param_type: param.param_type.clone(),
-            is_variadic: param.varargs,
+            // Note: For class diagrams, we don't support C-style variadic parameters (e.g., `foo(...)`),
+            // so we only consider the `varargs` flag for template pack expansions.
+            is_variadic: false,
+            is_pack_expansion: param.varargs,
         }
     }
 
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 cba49785..895219a9 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
@@ -106,3 +106,13 @@ fn test_syntax_coverage() {
 fn test_enum_value_sequence() {
     run_class_resolver_case("class_diagram_enum_value_sequence");
 }
+
+#[test]
+fn test_method_template_pack() {
+    run_class_resolver_case("method_template_pack");
+}
+
+#[test]
+fn test_class_template_pack() {
+    run_class_resolver_case("class_template_pack");
+}
diff --git a/tools/metamodel/class/class_logic.rs b/tools/metamodel/class/class_logic.rs
index 95a62f17..99af1d9b 100644
--- a/tools/metamodel/class/class_logic.rs
+++ b/tools/metamodel/class/class_logic.rs
@@ -54,7 +54,7 @@ pub struct SimpleEntity {
     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>>,
+    pub template_parameters: Option<Vec<TemplateParameter>>,
 
     /// Enum literals (only for Enum entity_type)
     pub enum_literals: Vec<EnumLiteral>,
@@ -87,6 +87,34 @@ pub enum EntityType {
     Enum,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum TemplateParameter {
+    Type {
+        name: String,
+        is_pack: bool,
+    },
+    NonType {
+        name: String,
+        value_type: String,
+        is_pack: bool,
+    },
+    Template {
+        name: String,
+        parameters: Vec<TemplateParameter>,
+        is_pack: bool,
+    },
+}
+
+impl TemplateParameter {
+    pub fn name(&self) -> &str {
+        match self {
+            Self::Type { name, .. } => name,
+            Self::NonType { name, .. } => name,
+            Self::Template { name, .. } => name,
+        }
+    }
+}
+
 /// Visibility modifier for members
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
 #[serde(rename_all = "lowercase")]
@@ -132,6 +160,12 @@ pub struct FunctionArgument {
     /// Parameter type
     pub param_type: Option<String>,
     pub is_variadic: bool,
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub is_pack_expansion: bool,
+}
+
+fn is_false(value: &bool) -> bool {
+    !*value
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@@ -168,7 +202,7 @@ pub struct Method {
     /// Method parameters
     pub parameters: Vec<FunctionArgument>,
     /// Template parameters for generic methods
-    pub template_parameters: Option<Vec<String>>,
+    pub template_parameters: Option<Vec<TemplateParameter>>,
     pub modifiers: Vec<MethodModifier>,
 }
 
diff --git a/tools/serialization/flatbuffers/class/class_diagram.fbs b/tools/serialization/flatbuffers/class/class_diagram.fbs
index 7aa9dcda..8adf8320 100644
--- a/tools/serialization/flatbuffers/class/class_diagram.fbs
+++ b/tools/serialization/flatbuffers/class/class_diagram.fbs
@@ -46,6 +46,20 @@ enum MethodModifier : byte {
     Noexcept = 6
 }
 
+enum TemplateParameterKind : byte {
+    Type = 0,
+    NonType = 1,
+    Template = 2
+}
+
+table TemplateParameter {
+    kind: TemplateParameterKind = Type;
+    name: string (required);
+    value_type: string;
+    parameters: [TemplateParameter];
+    is_pack: bool = false;
+}
+
 table TypeAlias {
     alias: string (required);
     original_type: string (required);
@@ -55,6 +69,7 @@ table FunctionArgument {
     name: string (required);
     param_type: string;
     is_variadic: bool = false;
+    is_pack_expansion: bool = false;
 }
 
 table MemberVariable {
@@ -69,7 +84,7 @@ table Method {
     return_type: string;
     visibility: Visibility = Public;
     parameters: [FunctionArgument];
-    template_parameters: [string];
+    template_parameters: [TemplateParameter];
     modifiers: [MethodModifier];
 }
 
@@ -94,7 +109,7 @@ table SimpleEntity {
     type_aliases: [TypeAlias];
     variables: [MemberVariable];
     methods: [Method];
-    template_parameters: [string];
+    template_parameters: [TemplateParameter];
     enum_literals: [EnumLiteral];
     relationships: [Relationship];
     source_file: string;
diff --git a/tools/serialization/flatbuffers/class/class_serializer.rs b/tools/serialization/flatbuffers/class/class_serializer.rs
index 97f017e8..e70b6379 100644
--- a/tools/serialization/flatbuffers/class/class_serializer.rs
+++ b/tools/serialization/flatbuffers/class/class_serializer.rs
@@ -13,7 +13,8 @@
 
 use class_diagram::{
     ClassDiagram, EntityType, EnumLiteral, FunctionArgument, MemberVariable, Method,
-    MethodModifier, RelationType, Relationship, SimpleEntity, TypeAlias, Visibility,
+    MethodModifier, RelationType, Relationship, SimpleEntity, TemplateParameter, TypeAlias,
+    Visibility,
 };
 use class_fbs::class_metamodel as fb;
 use flatbuffers::FlatBufferBuilder;
@@ -104,7 +105,7 @@ impl ClassSerializer {
         let template_parameters_offset = entity.template_parameters.as_ref().map(|parameters| {
             let template_offsets: Vec<_> = parameters
                 .iter()
-                .map(|parameter| builder.create_string(parameter))
+                .map(|parameter| Self::serialize_template_parameter(builder, parameter))
                 .collect();
             builder.create_vector(&template_offsets)
         });
@@ -204,7 +205,7 @@ impl ClassSerializer {
         let template_parameters_offset = method.template_parameters.as_ref().map(|parameters| {
             let template_offsets: Vec<_> = parameters
                 .iter()
-                .map(|parameter| builder.create_string(parameter))
+                .map(|parameter| Self::serialize_template_parameter(builder, parameter))
                 .collect();
             builder.create_vector(&template_offsets)
         });
@@ -245,6 +246,61 @@ impl ClassSerializer {
                 name: Some(name_offset),
                 param_type: param_type_offset,
                 is_variadic: param.is_variadic,
+                is_pack_expansion: param.is_pack_expansion,
+            },
+        )
+    }
+
+    fn serialize_template_parameter<'a>(
+        builder: &mut FlatBufferBuilder<'a>,
+        parameter: &TemplateParameter,
+    ) -> flatbuffers::WIPOffset<fb::TemplateParameter<'a>> {
+        let (kind, name, value_type, parameters, is_pack) = match parameter {
+            TemplateParameter::Type { name, is_pack } => {
+                (fb::TemplateParameterKind::Type, name, None, None, *is_pack)
+            }
+            TemplateParameter::NonType {
+                name,
+                value_type,
+                is_pack,
+            } => (
+                fb::TemplateParameterKind::NonType,
+                name,
+                Some(value_type),
+                None,
+                *is_pack,
+            ),
+            TemplateParameter::Template {
+                name,
+                parameters,
+                is_pack,
+            } => (
+                fb::TemplateParameterKind::Template,
+                name,
+                None,
+                Some(parameters),
+                *is_pack,
+            ),
+        };
+
+        let name_offset = builder.create_string(name);
+        let value_type_offset = value_type.map(|value| builder.create_string(value));
+        let parameters_offset = parameters.map(|nested_parameters| {
+            let nested_offsets: Vec<_> = nested_parameters
+                .iter()
+                .map(|nested| Self::serialize_template_parameter(builder, nested))
+                .collect();
+            builder.create_vector(&nested_offsets)
+        });
+
+        fb::TemplateParameter::create(
+            builder,
+            &fb::TemplateParameterArgs {
+                kind,
+                name: Some(name_offset),
+                value_type: value_type_offset,
+                parameters: parameters_offset,
+                is_pack,
             },
         )
     }
diff --git a/validation/core/src/readers/class_diagram_reader.rs b/validation/core/src/readers/class_diagram_reader.rs
index e87b4160..6980034b 100644
--- a/validation/core/src/readers/class_diagram_reader.rs
+++ b/validation/core/src/readers/class_diagram_reader.rs
@@ -21,7 +21,8 @@ use crate::models::ClassDiagramInputs;
 use crate::readers::Reader;
 use class_diagram::{
     ClassDiagram, EntityType, EnumLiteral, FunctionArgument, MemberVariable, Method,
-    MethodModifier, RelationType, Relationship, SimpleEntity, TypeAlias, Visibility,
+    MethodModifier, RelationType, Relationship, SimpleEntity, TemplateParameter, TypeAlias,
+    Visibility,
 };
 
 pub struct ClassDiagramReader;
@@ -32,6 +33,59 @@ fn collect_strings(
     values.map(|items| items.iter().map(|value| value.to_string()).collect())
 }
 
+fn read_template_parameters(
+    values: Option<
+        flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<fb_class::TemplateParameter<'_>>>,
+    >,
+    context: &str,
+) -> Result<Option<Vec<TemplateParameter>>, String> {
+    values
+        .map(|items| {
+            items
+                .iter()
+                .enumerate()
+                .map(|(index, parameter)| {
+                    read_template_parameter(
+                        parameter,
+                        &format!("{context}:template_parameter[{index}]"),
+                    )
+                })
+                .collect::<Result<Vec<_>, String>>()
+        })
+        .transpose()
+}
+
+fn read_template_parameter(
+    parameter: fb_class::TemplateParameter<'_>,
+    context: &str,
+) -> Result<TemplateParameter, String> {
+    match parameter.kind() {
+        fb_class::TemplateParameterKind::Type => Ok(TemplateParameter::Type {
+            name: parameter.name().to_string(),
+            is_pack: parameter.is_pack(),
+        }),
+        fb_class::TemplateParameterKind::NonType => Ok(TemplateParameter::NonType {
+            name: parameter.name().to_string(),
+            value_type: parameter.value_type().unwrap_or_default().to_string(),
+            is_pack: parameter.is_pack(),
+        }),
+        fb_class::TemplateParameterKind::Template => Ok(TemplateParameter::Template {
+            name: parameter.name().to_string(),
+            parameters: read_template_parameters(
+                parameter.parameters(),
+                &format!("{context}:parameters"),
+            )?
+            .unwrap_or_default(),
+            is_pack: parameter.is_pack(),
+        }),
+        _ => Err(unsupported_enum(
+            context,
+            "template_parameter_kind",
+            parameter.kind(),
+        )),
+    }
+}
+
 fn read_type_aliases(entity: fb_class::SimpleEntity<'_>) -> Vec<TypeAlias> {
     entity
         .type_aliases()
@@ -87,12 +141,16 @@ fn read_method(
                     name: param.name().to_string(),
                     param_type: param.param_type().map(|s| s.to_string()),
                     is_variadic: param.is_variadic(),
+                    is_pack_expansion: param.is_pack_expansion(),
                 })
                 .collect::<Vec<_>>()
         })
         .unwrap_or_default();
 
-    let template_parameters = collect_strings(method.template_parameters());
+    let template_parameters = read_template_parameters(
+        method.template_parameters(),
+        &format!("{path}:entity:{}:method:{}", entity.id(), method.name()),
+    )?;
 
     let modifiers = method
         .modifiers()
@@ -180,7 +238,10 @@ fn read_entity(entity: fb_class::SimpleEntity<'_>, path: &str) -> Result<SimpleE
         type_aliases: read_type_aliases(entity),
         variables: read_variables(entity, path)?,
         methods: read_methods(entity, path)?,
-        template_parameters: collect_strings(entity.template_parameters()),
+        template_parameters: read_template_parameters(
+            entity.template_parameters(),
+            &format!("{path}:entity:{}", entity.id()),
+        )?,
         enum_literals: read_enum_literals(entity),
         relationships: read_entity_relationships(entity, path)?,
         source_file: entity.source_file().map(|s| s.to_string()),