diff --git a/src/report_manager.cpp b/src/report_manager.cpp
index 21a9736..ab76a31 100644
--- a/src/report_manager.cpp
+++ b/src/report_manager.cpp
@@ -59,37 +59,53 @@
                     constexpr auto enabledDefault = true;
                     constexpr uint64_t appendLimitDefault = 0;
                     constexpr ReportUpdates reportUpdatesDefault =
-                        ReportUpdates::Overwrite;
-                    return addReport(
-                               yield, reportName, reportingType,
-                               emitsReadingsUpdate,
-                               logToMetricReportsCollection,
-                               Milliseconds(interval), appendLimitDefault,
-                               reportUpdatesToString(reportUpdatesDefault),
-                               convertToReadingParameters(
-                                   std::move(metricParams)),
-                               enabledDefault)
+                        ReportUpdates::overwrite;
+
+                    std::vector<ReportAction> reportActions;
+
+                    if (emitsReadingsUpdate)
+                    {
+                        reportActions.emplace_back(
+                            ReportAction::emitsReadingsUpdate);
+                    }
+                    if (logToMetricReportsCollection)
+                    {
+                        reportActions.emplace_back(
+                            ReportAction::logToMetricReportsCollection);
+                    }
+
+                    return addReport(yield, reportName,
+                                     utils::toReportingType(reportingType),
+                                     reportActions, Milliseconds(interval),
+                                     appendLimitDefault, reportUpdatesDefault,
+                                     convertToReadingParameters(
+                                         std::move(metricParams)),
+                                     enabledDefault)
                         .getPath();
                 });
 
             dbusIface.register_method(
                 "AddReportFutureVersion",
-
-                [this](
-                    boost::asio::yield_context& yield,
-                    const std::string& reportName,
-                    const std::string& reportingType,
-                    const std::string& reportUpdates,
-                    const uint64_t appendLimit, const bool emitsReadingsUpdate,
-                    const bool logToMetricReportsCollection,
-                    const uint64_t interval, ReadingParameters metricParams) {
+                [this](boost::asio::yield_context& yield,
+                       const std::string& reportName,
+                       const std::string& reportingType,
+                       const std::string& reportUpdates,
+                       const uint64_t appendLimit,
+                       const std::vector<std::string>& reportActions,
+                       const uint64_t interval,
+                       ReadingParameters metricParams) {
                     constexpr auto enabledDefault = true;
-                    return addReport(yield, reportName, reportingType,
-                                     emitsReadingsUpdate,
-                                     logToMetricReportsCollection,
+                    return addReport(yield, reportName,
+                                     utils::toReportingType(reportingType),
+                                     utils::transform(
+                                         reportActions,
+                                         [](const auto& reportAction) {
+                                             return utils::toReportAction(
+                                                 reportAction);
+                                         }),
                                      Milliseconds(interval), appendLimit,
-                                     reportUpdates, std::move(metricParams),
-                                     enabledDefault)
+                                     utils::toReportUpdates(reportUpdates),
+                                     std::move(metricParams), enabledDefault)
                         .getPath();
                 });
         });
@@ -114,10 +130,17 @@
 }
 
 void ReportManager::verifyAddReport(
-    const std::string& reportName, const std::string& reportingType,
-    Milliseconds interval, const std::string& reportUpdates,
+    const std::string& reportName, const ReportingType reportingType,
+    Milliseconds interval, const ReportUpdates reportUpdates,
     const std::vector<LabeledMetricParameters>& readingParams)
 {
+    if (reportingType == ReportingType::onChange)
+    {
+        throw sdbusplus::exception::SdBusError(
+            static_cast<int>(std::errc::invalid_argument),
+            "Invalid reportingType");
+    }
+
     if (reports.size() >= maxReports)
     {
         throw sdbusplus::exception::SdBusError(
@@ -136,17 +159,9 @@
         }
     }
 
-    if (std::find(supportedReportingType.begin(), supportedReportingType.end(),
-                  reportingType) == supportedReportingType.end())
-    {
-        throw sdbusplus::exception::SdBusError(
-            static_cast<int>(std::errc::invalid_argument),
-            "Invalid reportingType");
-    }
-
     verifyReportUpdates(reportUpdates);
 
-    if (reportingType == "Periodic" && interval < minInterval)
+    if (reportingType == ReportingType::periodic && interval < minInterval)
     {
         throw sdbusplus::exception::SdBusError(
             static_cast<int>(std::errc::invalid_argument), "Invalid interval");
@@ -179,24 +194,23 @@
 
 interfaces::Report& ReportManager::addReport(
     boost::asio::yield_context& yield, const std::string& reportName,
-    const std::string& reportingType, const bool emitsReadingsUpdate,
-    const bool logToMetricReportsCollection, Milliseconds interval,
-    const uint64_t appendLimit, const std::string& reportUpdates,
+    const ReportingType reportingType,
+    const std::vector<ReportAction>& reportActions, Milliseconds interval,
+    const uint64_t appendLimit, const ReportUpdates reportUpdates,
     ReadingParameters metricParams, const bool enabled)
 {
     auto labeledMetricParams =
         reportFactory->convertMetricParams(yield, metricParams);
 
-    return addReport(reportName, reportingType, emitsReadingsUpdate,
-                     logToMetricReportsCollection, interval, appendLimit,
-                     reportUpdates, std::move(labeledMetricParams), enabled);
+    return addReport(reportName, reportingType, reportActions, interval,
+                     appendLimit, reportUpdates, std::move(labeledMetricParams),
+                     enabled);
 }
 
 interfaces::Report& ReportManager::addReport(
-    const std::string& reportName, const std::string& reportingType,
-    const bool emitsReadingsUpdate, const bool logToMetricReportsCollection,
-    Milliseconds interval, const uint64_t appendLimit,
-    const std::string& reportUpdates,
+    const std::string& reportName, const ReportingType reportingType,
+    const std::vector<ReportAction>& reportActions, Milliseconds interval,
+    const uint64_t appendLimit, const ReportUpdates reportUpdates,
     std::vector<LabeledMetricParameters> labeledMetricParams,
     const bool enabled)
 {
@@ -204,9 +218,8 @@
                     labeledMetricParams);
 
     reports.emplace_back(reportFactory->make(
-        reportName, reportingType, emitsReadingsUpdate,
-        logToMetricReportsCollection, interval, appendLimit, reportUpdates,
-        *this, *reportStorage, labeledMetricParams, enabled));
+        reportName, reportingType, reportActions, interval, appendLimit,
+        reportUpdates, *this, *reportStorage, labeledMetricParams, enabled));
     return *reports.back();
 }
 
@@ -227,24 +240,24 @@
                 throw std::logic_error("Invalid version");
             }
             std::string& name = data->at("Name").get_ref<std::string&>();
-            std::string& reportingType =
-                data->at("ReportingType").get_ref<std::string&>();
-            bool emitsReadingsSignal =
-                data->at("EmitsReadingsUpdate").get<bool>();
-            bool logToMetricReportsCollection =
-                data->at("LogToMetricReportsCollection").get<bool>();
+
+            uint32_t reportingType = data->at("ReportingType").get<uint32_t>();
+            std::vector<ReportAction> reportActions = utils::transform(
+                data->at("ReportActions").get<std::vector<uint32_t>>(),
+                [](const auto reportAction) {
+                    return utils::toReportAction(reportAction);
+                });
             uint64_t interval = data->at("Interval").get<uint64_t>();
             uint64_t appendLimit = data->at("AppendLimit").get<uint64_t>();
-            std::string reportUpdates =
-                data->at("ReportUpdates").get<std::string>();
+            uint32_t reportUpdates = data->at("ReportUpdates").get<uint32_t>();
             auto readingParameters =
                 data->at("ReadingParameters")
                     .get<std::vector<LabeledMetricParameters>>();
 
-            addReport(name, reportingType, emitsReadingsSignal,
-                      logToMetricReportsCollection, Milliseconds(interval),
-                      appendLimit, reportUpdates, std::move(readingParameters),
-                      enabled);
+            addReport(name, utils::toReportingType(reportingType),
+                      reportActions, Milliseconds(interval), appendLimit,
+                      utils::toReportUpdates(reportUpdates),
+                      std::move(readingParameters), enabled);
         }
         catch (const std::exception& e)
         {
@@ -271,7 +284,7 @@
     }
 }
 
-void ReportManager::verifyReportUpdates(const std::string& reportUpdates)
+void ReportManager::verifyReportUpdates(const ReportUpdates reportUpdates)
 {
     if (std::find(supportedReportUpdates.begin(), supportedReportUpdates.end(),
                   reportUpdates) == supportedReportUpdates.end())