diff --git a/dump_types.mako.cpp b/dump_types.mako.cpp
index 251599f..969bfff 100644
--- a/dump_types.mako.cpp
+++ b/dump_types.mako.cpp
@@ -1,6 +1,6 @@
-## This file is a template.  The comment below is emitted
+## This file is a template.The comment below is emitted
 ## into the rendered file; feel free to edit this file.
-// !!! WARNING: This is a GENERATED Code..Please do NOT Edit !!!
+//  !!! WARNING: This is a GENERATED Code..Please do NOT Edit !!!
 #include "dump_types.hpp"
 
 #include <phosphor-logging/elog-errors.hpp>
@@ -21,12 +21,34 @@
 % endfor
 };
 
+<%
+map_keys = set()
+%>
 DUMP_TYPE_TO_STRING_MAP dumpTypeToStringMap = {
 % for item in DUMP_TYPE_TABLE:
   % for key, values in item.items():
-    {DumpTypes::${values[0].upper()}, "${values[0]}"},
+    % if values[0].upper() not in map_keys:
+        {DumpTypes::${values[0].upper()}, "${values[0]}"},
+        <% map_keys.add(values[0].upper()) %>
+    % endif
   % endfor
 % endfor
+% for key, values in ERROR_TYPE_DICT.items():
+    % if key.upper() not in map_keys:
+        {DumpTypes::${key.upper()}, "${key}"},
+        <% map_keys.add(key.upper()) %>
+    % endif
+% endfor
+};
+
+const ErrorMap errorMap = {
+% for key, errors in ERROR_TYPE_DICT.items():
+    {"${key}", {
+    % for error in errors:
+        "${error}",
+    % endfor
+    }},
+% endfor
 };
 
 std::optional<std::string> dumpTypeToString(const DumpTypes& dumpType)
@@ -85,5 +107,24 @@
     return dumpType;
 }
 
+bool isErrorTypeValid(const std::string& errorType)
+{
+    const auto it = errorMap.find(errorType);
+    return it != errorMap.end();
+}
+
+std::optional<ErrorType> findErrorType(const std::string& errString)
+{
+    for (const auto& [type, errorList] : errorMap)
+    {
+        auto error = std::find(errorList.begin(), errorList.end(), errString);
+        if (error != errorList.end())
+        {
+            return type;
+        }
+    }
+    return std::nullopt;
+}
+
 } // namespace dump
 } // namespace phosphor
diff --git a/dump_types.mako.hpp b/dump_types.mako.hpp
index c46bcdc..28f052c 100644
--- a/dump_types.mako.hpp
+++ b/dump_types.mako.hpp
@@ -7,6 +7,7 @@
 #include <ranges>
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 namespace phosphor
 {
@@ -21,13 +22,28 @@
 // Dump collection indicator
 using DUMP_COLLECTION_TYPE = std::string;
 
+using ErrorType = std::string;
+using Error = std::string;
+using ErrorList = std::vector<Error>;
+using ErrorMap = std::unordered_map<ErrorType, ErrorList>;
+
 // Dump types
+<% enum_values = set() %>
 enum class DumpTypes {
 % for item in DUMP_TYPE_TABLE:
   % for key, values in item.items():
-    ${values[0].upper()},
+    % if values[0].upper() not in enum_values:
+        ${values[0].upper()},
+        <% enum_values.add(values[0].upper()) %>
+    % endif
   % endfor
 % endfor
+% for key in ERROR_TYPE_DICT:
+    % if key.upper() not in enum_values:
+        ${key.upper()},
+        <% enum_values.add(key.upper()) %>
+    % endif
+% endfor
 };
 
 // A table of dump types
@@ -76,5 +92,32 @@
 DumpTypes validateDumpType(const std::string& type,
                            const std::string& category);
 
+/**
+ * @brief Checks if the provided error type is valid.
+ *
+ * This function verifies the validity of the error type by checking if it
+ * exists in the error map.
+ *
+ * @param[in] errorType - The string representation of the error type to
+ * validate.
+ *
+ * @return True if the error type exists in the error map, False otherwise.
+ */
+bool isErrorTypeValid(const std::string& errorType);
+
+/**
+ * @brief Finds the error type based on the provided error string.
+ *
+ * This function searches the error map for the provided error string.
+ * If it finds the string in the list of errors for a specific error type,
+ * it returns that error type.
+ *
+ * @param[in] errString - The string representation of the error to search for.
+ *
+ * @return An optional containing the error type if found. If the error string
+ * is not found in the map, returns an empty optional.
+ */
+std::optional<ErrorType> findErrorType(const std::string& errString);
+
 } // namespace dump
 } // namespace phosphor
diff --git a/dump_utils.hpp b/dump_utils.hpp
index 01e4166..7bf8a7b 100644
--- a/dump_utils.hpp
+++ b/dump_utils.hpp
@@ -335,5 +335,46 @@
     return T{};
 }
 
+/**
+ * @brief This function fetches the dump type associated with a particular
+ * error.
+ *
+ * @param[in] params The map of parameters passed as input.
+ *
+ * @return The dump type associated with the error.
+ *
+ * @throw std::invalid_argument If the dump type associated with the error
+ * type is not found in the map.
+ */
+inline DumpTypes getErrorDumpType(phosphor::dump::DumpCreateParams& params)
+{
+    using CreateParameters =
+        sdbusplus::xyz::openbmc_project::Dump::server::Create::CreateParameters;
+    using DumpIntr = sdbusplus::common::xyz::openbmc_project::dump::Create;
+    using InvalidArgument =
+        sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument;
+    using Argument = xyz::openbmc_project::Common::InvalidArgument;
+
+    std::string errorType = extractParameter<std::string>(
+        DumpIntr::convertCreateParametersToString(CreateParameters::ErrorType),
+        params);
+    if (!isErrorTypeValid(errorType))
+    {
+        lg2::error("An invalid error type passed type: {ERROR_TYPE}",
+                   "ERROR_TYPE", errorType);
+        elog<InvalidArgument>(Argument::ARGUMENT_NAME("ERROR_TYPE"),
+                              Argument::ARGUMENT_VALUE(errorType.c_str()));
+    }
+    auto type = stringToDumpType(errorType);
+    if (type.has_value())
+    {
+        return type.value();
+    }
+
+    // Ideally this should never happen, because if the error type is valid
+    // it should be present in the dumpTypeToStringMap
+    throw std::invalid_argument{"Dump type not found"};
+}
+
 } // namespace dump
 } // namespace phosphor
diff --git a/elog_watch.cpp b/elog_watch.cpp
index 84eaff8..93c73e9 100644
--- a/elog_watch.cpp
+++ b/elog_watch.cpp
@@ -4,7 +4,7 @@
 
 #include "dump_internal.hpp"
 #include "dump_serialize.hpp"
-#include "errors_map.hpp"
+#include "dump_types.hpp"
 #include "xyz/openbmc_project/Dump/Create/error.hpp"
 
 #include <cereal/cereal.hpp>
@@ -109,23 +109,15 @@
         return;
     }
 
-    EType errorType;
-    for (const auto& [type, errorList] : errorMap)
+    auto etype = findErrorType(data);
+    if (!etype.has_value())
     {
-        auto error = std::find(errorList.begin(), errorList.end(), data);
-        if (error != errorList.end())
-        {
-            errorType = type;
-            break;
-        }
-    }
-
-    // error not supported in the configuration
-    if (errorType.empty())
-    {
+        // error not supported in the configuration
         return;
     }
 
+    auto errorType = etype.value();
+
     std::vector<std::string> fullPaths;
     fullPaths.push_back(objectPath);
 
diff --git a/errors_map.hpp b/errors_map.hpp
deleted file mode 100644
index 1389509..0000000
--- a/errors_map.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include <map>
-#include <string>
-#include <vector>
-
-using EType = std::string;
-using Error = std::string;
-using ErrorList = std::vector<Error>;
-using ErrorMap = std::map<EType, ErrorList>;
-
-extern const ErrorMap errorMap;
diff --git a/errors_map.mako.cpp b/errors_map.mako.cpp
deleted file mode 100644
index b8246cf..0000000
--- a/errors_map.mako.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-## This file is a template.  The comment below is emitted
-## into the rendered file; feel free to edit this file.
-// !!! WARNING: This is a GENERATED Code..Please do NOT Edit !!!
-#include "errors_map.hpp"
-
-const ErrorMap errorMap = {
-% for key, errors in errDict.items():
-    {"${key}", {
-    % for error in errors:
-        "${error}",
-    % endfor
-    }},
-% endfor
-};
diff --git a/map_gen.py b/map_gen.py
index 39215d1..367587c 100755
--- a/map_gen.py
+++ b/map_gen.py
@@ -14,10 +14,18 @@
 
     parser.add_argument(
         "-i",
-        "--input_yaml",
-        dest="input_yaml",
-        default="example.yaml",
-        help="input yaml file to parse",
+        "--input_dump_type_yaml",
+        dest="input_dump_type_yaml",
+        default="example_dump_types.yaml",
+        help="input dump type yaml file to parse",
+    )
+
+    parser.add_argument(
+        "-j",
+        "--input_error_type_yaml",
+        dest="input_error_type_yaml",
+        default="example_errors_watch.yaml",
+        help="input error type yaml file to parse",
     )
 
     parser.add_argument(
@@ -36,26 +44,20 @@
         help="output cpp file",
     )
 
-    parser.add_argument(
-        "-v",
-        "--var_name",
-        dest="var_name",
-        default="mapping",
-        help="variable name to use in the template",
-    )
-
     args = parser.parse_args()
 
-    with open(os.path.join(script_dir, args.input_yaml), "r") as fd:
-        yaml_dict = yaml.safe_load(fd)
+    with open(os.path.join(script_dir, args.input_dump_type_yaml), "r") as fd:
+        yaml_dict1 = yaml.safe_load(fd)
+
+    with open(os.path.join(script_dir, args.input_error_type_yaml), "r") as fd:
+        yaml_dict2 = yaml.safe_load(fd)
 
     template = os.path.join(script_dir, args.template)
     t = Template(filename=template)
     with open(args.output_file, "w") as fd:
-        if args.var_name == "errDict":
-            fd.write(t.render(errDict=yaml_dict))
-        else:
-            fd.write(t.render(DUMP_TYPE_TABLE=yaml_dict))
+        fd.write(
+            t.render(DUMP_TYPE_TABLE=yaml_dict1, ERROR_TYPE_DICT=yaml_dict2)
+        )
 
 
 if __name__ == "__main__":
diff --git a/meson.build b/meson.build
index 54a233c..f7acc64 100644
--- a/meson.build
+++ b/meson.build
@@ -155,16 +155,17 @@
                         map_gen_file_loc,
                         '-i',
                         meson.build_root() + '/' +  combined_yaml_file,
+                        '-j',
+                        get_option('ERROR_MAP_YAML'),
                         '-t',
                         'dump_types.mako.hpp',
-                        '-v',
-                        'DUMP_TYPE_TABLE',
                         '-o',
                         'dump_types.hpp'
                     ],
                     depend_files : [ 'dump_types.mako.hpp',
                                      'map_gen.py',
-                                     meson.build_root() + '/' +  combined_yaml_file
+                                     meson.build_root() + '/' +  combined_yaml_file,
+                                     get_option('ERROR_MAP_YAML')
                                    ],
                     output : 'dump_types.hpp'
                  )
@@ -176,39 +177,19 @@
                         map_gen_file_loc,
                         '-i',
                         meson.build_root() + '/' +  combined_yaml_file,
+                        '-j',
+                        get_option('ERROR_MAP_YAML'),
                         '-t',
                         'dump_types.mako.cpp',
-                        '-v',
-                        'DUMP_TYPE_TABLE',
                         '-o',
                         'dump_types.cpp'
                     ],
                     depend_files : [ 'dump_types.mako.cpp',
                                      'map_gen.py',
-                                     meson.build_root() + '/' +  combined_yaml_file
-                                   ],
-                    output : 'dump_types.cpp'
-                 )
-
-errors_map_cpp = custom_target(
-                    'errors_map.cpp',
-                    command : [
-                        python,
-                        map_gen_file_loc,
-                        '-i',
-                        get_option('ERROR_MAP_YAML'),
-                        '-t',
-                        'errors_map.mako.cpp',
-                        '-v',
-                        'errDict',
-                        '-o',
-                        'errors_map.cpp'
-                    ],
-                    depend_files : [ 'errors_map.mako.cpp',
-                                     'map_gen.py',
+                                     meson.build_root() + '/' +  combined_yaml_file,
                                      get_option('ERROR_MAP_YAML')
                                    ],
-                    output : 'errors_map.cpp'
+                    output : 'dump_types.cpp'
                  )
 
 phosphor_dump_manager_sources = [
@@ -218,7 +199,6 @@
         'dump_manager_main.cpp',
         'dump_serialize.cpp',
         'elog_watch.cpp',
-        errors_map_cpp,
         common_hpp,
         server_hpp,
         server_cpp,