diff --git a/src/report.cpp b/src/report.cpp
index 9ee60a4..c2a0371 100644
--- a/src/report.cpp
+++ b/src/report.cpp
@@ -204,12 +204,11 @@
 
 void Report::setReadingBuffer(const ReportUpdates newReportUpdates)
 {
-    if (reportingType != ReportingType::onRequest &&
-        (reportUpdates == ReportUpdates::overwrite ||
-         newReportUpdates == ReportUpdates::overwrite))
+    const auto newBufferSize =
+        deduceBufferSize(newReportUpdates, reportingType);
+    if (readingsBuffer.size() != newBufferSize)
     {
-        readingsBuffer.clearAndResize(
-            deduceBufferSize(newReportUpdates, reportingType));
+        readingsBuffer.clearAndResize(newBufferSize);
     }
 }
 
diff --git a/src/report_manager.cpp b/src/report_manager.cpp
index 1677bb3..5812311 100644
--- a/src/report_manager.cpp
+++ b/src/report_manager.cpp
@@ -9,7 +9,9 @@
 
 #include <phosphor-logging/log.hpp>
 #include <sdbusplus/exception.hpp>
+#include <sdbusplus/unpack_properties.hpp>
 
+#include <optional>
 #include <stdexcept>
 #include <system_error>
 
@@ -99,24 +101,46 @@
                 "AddReportFutureVersion",
                 [this](
                     boost::asio::yield_context& yield,
-                    const std::string& reportId, 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, reportId, reportName,
-                                     utils::toReportingType(reportingType),
-                                     utils::transform(
-                                         reportActions,
-                                         [](const auto& reportAction) {
-                                             return utils::toReportAction(
-                                                 reportAction);
-                                         }),
-                                     Milliseconds(interval), appendLimit,
-                                     utils::toReportUpdates(reportUpdates),
-                                     std::move(metricParams), enabledDefault)
+                    const std::vector<
+                        std::pair<std::string, AddReportFutureVersionVariant>>&
+                        properties) {
+                    std::optional<std::string> reportId;
+                    std::optional<std::string> reportName;
+                    std::optional<std::string> reportingType;
+                    std::optional<std::vector<std::string>> reportActions;
+                    std::optional<uint64_t> interval;
+                    std::optional<uint64_t> appendLimit;
+                    std::optional<std::string> reportUpdates;
+                    std::optional<ReadingParameters> metricParams;
+                    std::optional<bool> enabled;
+
+                    sdbusplus::unpackProperties(
+                        properties, "Id", reportId, "Name", reportName,
+                        "ReportingType", reportingType, "ReportActions",
+                        reportActions, "Interval", interval, "AppendLimit",
+                        appendLimit, "ReportUpdates", reportUpdates,
+                        "MetricParams", metricParams, "Enabled", enabled);
+
+                    return addReport(
+                               yield, reportId.value_or(""),
+                               reportName.value_or(""),
+                               utils::toReportingType(
+                                   reportingType.value_or(utils::enumToString(
+                                       ReportingType::onRequest))),
+                               utils::transform(
+                                   reportActions.value_or(
+                                       std::vector<std::string>{}),
+                                   [](const auto& reportAction) {
+                                       return utils::toReportAction(
+                                           reportAction);
+                                   }),
+                               Milliseconds(interval.value_or(0)),
+                               appendLimit.value_or(0),
+                               utils::toReportUpdates(
+                                   reportUpdates.value_or(utils::enumToString(
+                                       ReportUpdates::overwrite))),
+                               metricParams.value_or(ReadingParameters{}),
+                               enabled.value_or(true))
                         .getPath();
                 });
         });
diff --git a/src/types/report_types.hpp b/src/types/report_types.hpp
index d927d0e..49dca73 100644
--- a/src/types/report_types.hpp
+++ b/src/types/report_types.hpp
@@ -13,6 +13,7 @@
 #include <string>
 #include <tuple>
 #include <type_traits>
+#include <variant>
 #include <vector>
 
 using ReadingParametersPastVersion =
@@ -30,5 +31,9 @@
     utils::tstring::Id, utils::tstring::CollectionTimeScope,
     utils::tstring::CollectionDuration>;
 
+using AddReportFutureVersionVariant =
+    std::variant<std::monostate, bool, uint64_t, std::string,
+                 std::vector<std::string>, ReadingParameters>;
+
 ReadingParameters
     toReadingParameters(const std::vector<LabeledMetricParameters>& labeled);
diff --git a/src/types/trigger_types.hpp b/src/types/trigger_types.hpp
index 4d0b3bd..9a053c8 100644
--- a/src/types/trigger_types.hpp
+++ b/src/types/trigger_types.hpp
@@ -4,6 +4,7 @@
 #include "utils/conversion.hpp"
 #include "utils/labeled_tuple.hpp"
 #include "utils/tstring.hpp"
+#include "utils/variant_utils.hpp"
 
 #include <string>
 #include <tuple>
@@ -144,8 +145,7 @@
                  std::vector<discrete::ThresholdParam>>;
 
 using TriggerThresholdParams =
-    std::variant<std::vector<numeric::ThresholdParam>,
-                 std::vector<discrete::ThresholdParam>>;
+    utils::WithoutMonostate<TriggerThresholdParamsExt>;
 
 using LabeledTriggerThresholdParams =
     std::variant<std::vector<numeric::LabeledThresholdParam>,
diff --git a/src/utils/circular_vector.hpp b/src/utils/circular_vector.hpp
index f7ac8e5..be13873 100644
--- a/src/utils/circular_vector.hpp
+++ b/src/utils/circular_vector.hpp
@@ -53,6 +53,11 @@
         return vec.end();
     }
 
+    size_t size() const
+    {
+        return maxSize;
+    }
+
   private:
     std::vector<T>& vec;
     size_t maxSize = 0;
diff --git a/src/utils/variant_utils.hpp b/src/utils/variant_utils.hpp
new file mode 100644
index 0000000..0843818
--- /dev/null
+++ b/src/utils/variant_utils.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <concepts>
+#include <variant>
+
+namespace utils
+{
+namespace details
+{
+
+template <class T, class... Args>
+auto removeMonostate(std::variant<T, Args...>) -> std::variant<T, Args...>;
+
+template <class... Args>
+auto removeMonostate(std::variant<std::monostate, Args...>)
+    -> std::variant<Args...>;
+
+template <class Variant>
+struct WithoutMonostate
+{
+  private:
+  public:
+    using type = decltype(removeMonostate(Variant{}));
+};
+
+} // namespace details
+
+template <class Variant>
+using WithoutMonostate = typename details::WithoutMonostate<Variant>::type;
+
+} // namespace utils