diff --git a/src/discrete_threshold.cpp b/src/discrete_threshold.cpp
index 3c98c93..a2073b7 100644
--- a/src/discrete_threshold.cpp
+++ b/src/discrete_threshold.cpp
@@ -4,37 +4,39 @@
 
 DiscreteThreshold::DiscreteThreshold(
     boost::asio::io_context& ioc, Sensors sensorsIn,
-    std::vector<std::string> sensorNames,
     std::vector<std::unique_ptr<interfaces::TriggerAction>> actionsIn,
     Milliseconds dwellTimeIn, double thresholdValueIn,
-    const std::string& name) :
+    const std::string& nameIn, const discrete::Severity severityIn) :
     ioc(ioc),
-    sensors(std::move(sensorsIn)), actions(std::move(actionsIn)),
-    dwellTime(dwellTimeIn), thresholdValue(thresholdValueIn), name(name)
+    actions(std::move(actionsIn)), dwellTime(dwellTimeIn),
+    thresholdValue(thresholdValueIn), name(nameIn), severity(severityIn)
 {
-    details.reserve(sensors.size());
-    for (size_t i = 0; i < sensors.size(); i++)
+    for (const auto& sensor : sensorsIn)
     {
-        details.emplace_back(sensorNames[i], false, ioc);
+        sensorDetails.emplace(sensor, makeDetails(sensor->getName()));
     }
 }
 
 void DiscreteThreshold::initialize()
 {
-    for (auto& sensor : sensors)
-    {
-        sensor->registerForUpdates(weak_from_this());
-    }
+    ThresholdOperations().initialize(this);
+}
+
+void DiscreteThreshold::updateSensors(Sensors newSensors)
+{
+    ThresholdOperations().updateSensors(this, std::move(newSensors));
 }
 
 DiscreteThreshold::ThresholdDetail&
-    DiscreteThreshold::getDetails(interfaces::Sensor& sensor)
+    DiscreteThreshold::getDetails(const interfaces::Sensor& sensor)
 {
-    auto it =
-        std::find_if(sensors.begin(), sensors.end(),
-                     [&sensor](const auto& x) { return &sensor == x.get(); });
-    auto index = std::distance(sensors.begin(), it);
-    return details.at(index);
+    return ThresholdOperations().getDetails(this, sensor);
+}
+
+std::shared_ptr<DiscreteThreshold::ThresholdDetail>
+    DiscreteThreshold::makeDetails(const std::string& sensorName)
+{
+    return std::make_shared<ThresholdDetail>(sensorName, false, ioc);
 }
 
 void DiscreteThreshold::sensorUpdated(interfaces::Sensor& sensor,
@@ -44,7 +46,8 @@
 void DiscreteThreshold::sensorUpdated(interfaces::Sensor& sensor,
                                       Milliseconds timestamp, double value)
 {
-    auto& [sensorName, dwell, timer] = getDetails(sensor);
+    auto& details = getDetails(sensor);
+    auto& [sensorName, dwell, timer] = details;
 
     if (thresholdValue)
     {
@@ -55,15 +58,18 @@
         }
         else if (value == thresholdValue)
         {
-            startTimer(sensor, timestamp, value);
+            startTimer(details, timestamp, value);
         }
     }
 }
 
-void DiscreteThreshold::startTimer(interfaces::Sensor& sensor,
+void DiscreteThreshold::startTimer(DiscreteThreshold::ThresholdDetail& details,
                                    Milliseconds timestamp, double value)
 {
-    auto& [sensorName, dwell, timer] = getDetails(sensor);
+    const auto& sensorName = details.sensorName;
+    auto& dwell = details.dwell;
+    auto& timer = details.timer;
+
     if (dwellTime == Milliseconds::zero())
     {
         commit(sensorName, timestamp, value);
@@ -72,7 +78,7 @@
     {
         dwell = true;
         timer.expires_after(dwellTime);
-        timer.async_wait([this, &sensor, timestamp,
+        timer.async_wait([this, &sensorName, &dwell, timestamp,
                           value](const boost::system::error_code ec) {
             if (ec)
             {
@@ -80,7 +86,6 @@
                     "Timer has been canceled");
                 return;
             }
-            auto& [sensorName, dwell, timer] = getDetails(sensor);
             commit(sensorName, timestamp, value);
             dwell = false;
         });
@@ -95,3 +100,9 @@
         action->commit(sensorName, timestamp, value);
     }
 }
+
+LabeledThresholdParam DiscreteThreshold::getThresholdParam() const
+{
+    return discrete::LabeledThresholdParam(name, severity, dwellTime.count(),
+                                           std::to_string(thresholdValue));
+}
diff --git a/src/discrete_threshold.hpp b/src/discrete_threshold.hpp
index c9bca4d..1f145f4 100644
--- a/src/discrete_threshold.hpp
+++ b/src/discrete_threshold.hpp
@@ -6,10 +6,12 @@
 #include "interfaces/trigger_action.hpp"
 #include "types/duration_types.hpp"
 #include "types/trigger_types.hpp"
+#include "utils/threshold_operations.hpp"
 
 #include <boost/asio/steady_timer.hpp>
 
 #include <chrono>
+#include <map>
 #include <memory>
 #include <vector>
 
@@ -21,23 +23,26 @@
   public:
     DiscreteThreshold(
         boost::asio::io_context& ioc, Sensors sensors,
-        std::vector<std::string> sensorNames,
         std::vector<std::unique_ptr<interfaces::TriggerAction>> actions,
-        Milliseconds dwellTime, double thresholdValue, const std::string& name);
+        Milliseconds dwellTime, double thresholdValue, const std::string& name,
+        const discrete::Severity severity);
     DiscreteThreshold(const DiscreteThreshold&) = delete;
     DiscreteThreshold(DiscreteThreshold&&) = delete;
 
     void initialize() override;
     void sensorUpdated(interfaces::Sensor&, Milliseconds) override;
     void sensorUpdated(interfaces::Sensor&, Milliseconds, double) override;
+    LabeledThresholdParam getThresholdParam() const override;
+    void updateSensors(Sensors newSensors) override;
 
   private:
     boost::asio::io_context& ioc;
-    const Sensors sensors;
     const std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
     const Milliseconds dwellTime;
     const double thresholdValue;
     const std::string name;
+    const discrete::Severity severity;
+    bool initialized = false;
 
     struct ThresholdDetail
     {
@@ -51,9 +56,15 @@
             dwell(dwell), timer(ioc)
         {}
     };
-    std::vector<ThresholdDetail> details;
+    using SensorDetails =
+        std::unordered_map<std::shared_ptr<interfaces::Sensor>,
+                           std::shared_ptr<ThresholdDetail>>;
+    SensorDetails sensorDetails;
 
-    void startTimer(interfaces::Sensor&, Milliseconds, double);
+    friend ThresholdOperations;
+
+    void startTimer(ThresholdDetail&, Milliseconds, double);
     void commit(const std::string&, Milliseconds, double);
-    ThresholdDetail& getDetails(interfaces::Sensor& sensor);
+    ThresholdDetail& getDetails(const interfaces::Sensor& sensor);
+    std::shared_ptr<ThresholdDetail> makeDetails(const std::string& sensorName);
 };
diff --git a/src/interfaces/sensor.hpp b/src/interfaces/sensor.hpp
index 6a6bcf7..7764b37 100644
--- a/src/interfaces/sensor.hpp
+++ b/src/interfaces/sensor.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "types/sensor_types.hpp"
+
 #include <chrono>
 #include <memory>
 #include <ostream>
@@ -44,9 +46,12 @@
 
     virtual Id id() const = 0;
     virtual std::string metadata() const = 0;
+    virtual std::string getName() const = 0;
     virtual void registerForUpdates(const std::weak_ptr<SensorListener>&) = 0;
     virtual void
         unregisterFromUpdates(const std::weak_ptr<SensorListener>&) = 0;
+
+    virtual LabeledSensorInfo getLabeledSensorInfo() const = 0;
 };
 
 } // namespace interfaces
diff --git a/src/interfaces/threshold.hpp b/src/interfaces/threshold.hpp
index 23ff9d9..1efee2e 100644
--- a/src/interfaces/threshold.hpp
+++ b/src/interfaces/threshold.hpp
@@ -1,5 +1,8 @@
 #pragma once
 
+#include "interfaces/sensor.hpp"
+#include "types/trigger_types.hpp"
+
 namespace interfaces
 {
 
@@ -9,6 +12,8 @@
     virtual ~Threshold() = default;
 
     virtual void initialize() = 0;
+    virtual LabeledThresholdParam getThresholdParam() const = 0;
+    virtual void updateSensors(Sensors newSensors) = 0;
 };
 
 } // namespace interfaces
diff --git a/src/interfaces/trigger_factory.hpp b/src/interfaces/trigger_factory.hpp
index ee85063..0e7ac7f 100644
--- a/src/interfaces/trigger_factory.hpp
+++ b/src/interfaces/trigger_factory.hpp
@@ -1,8 +1,11 @@
 #pragma once
 
 #include "interfaces/json_storage.hpp"
+#include "interfaces/sensor.hpp"
+#include "interfaces/threshold.hpp"
 #include "interfaces/trigger.hpp"
 #include "interfaces/trigger_manager.hpp"
+#include "sensor.hpp"
 #include "types/trigger_types.hpp"
 
 #include <boost/asio/spawn.hpp>
@@ -31,6 +34,20 @@
     virtual std::vector<LabeledSensorInfo>
         getLabeledSensorsInfo(boost::asio::yield_context& yield,
                               const SensorsInfo& sensorsInfo) const = 0;
+
+    virtual std::vector<LabeledSensorInfo>
+        getLabeledSensorsInfo(const SensorsInfo& sensorsInfo) const = 0;
+
+    virtual void updateThresholds(
+        std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+        const std::vector<::TriggerAction>& triggerActions,
+        const std::shared_ptr<std::vector<std::string>>& reportIds,
+        const Sensors& sensors,
+        const LabeledTriggerThresholdParams& newParams) const = 0;
+
+    virtual void updateSensors(
+        Sensors& currentSensors,
+        const std::vector<LabeledSensorInfo>& labeledSensorsInfo) const = 0;
 };
 
 } // namespace interfaces
diff --git a/src/metric.cpp b/src/metric.cpp
index 582e506..3e450d6 100644
--- a/src/metric.cpp
+++ b/src/metric.cpp
@@ -2,6 +2,7 @@
 
 #include "details/collection_function.hpp"
 #include "types/report_types.hpp"
+#include "types/sensor_types.hpp"
 #include "utils/labeled_tuple.hpp"
 #include "utils/transform.hpp"
 
@@ -213,8 +214,8 @@
 LabeledMetricParameters Metric::dumpConfiguration() const
 {
     auto sensorPath = utils::transform(sensors, [this](const auto& sensor) {
-        return LabeledSensorParameters(sensor->id().service, sensor->id().path,
-                                       sensor->metadata());
+        return LabeledSensorInfo(sensor->id().service, sensor->id().path,
+                                 sensor->metadata());
     });
 
     return LabeledMetricParameters(std::move(sensorPath), operationType, id,
diff --git a/src/numeric_threshold.cpp b/src/numeric_threshold.cpp
index 3bec427..f152e76 100644
--- a/src/numeric_threshold.cpp
+++ b/src/numeric_threshold.cpp
@@ -4,41 +4,40 @@
 
 NumericThreshold::NumericThreshold(
     boost::asio::io_context& ioc, Sensors sensorsIn,
-    std::vector<std::string> sensorNames,
     std::vector<std::unique_ptr<interfaces::TriggerAction>> actionsIn,
-    Milliseconds dwellTimeIn, numeric::Direction direction,
-    double thresholdValueIn) :
+    Milliseconds dwellTimeIn, numeric::Direction directionIn,
+    double thresholdValueIn, numeric::Type typeIn) :
     ioc(ioc),
-    sensors(std::move(sensorsIn)), actions(std::move(actionsIn)),
-    dwellTime(dwellTimeIn), direction(direction),
-    thresholdValue(thresholdValueIn)
+    actions(std::move(actionsIn)), dwellTime(dwellTimeIn),
+    direction(directionIn), thresholdValue(thresholdValueIn), type(typeIn)
 {
-    details.reserve(sensors.size());
-    for (size_t i = 0; i < sensors.size(); i++)
+    for (const auto& sensor : sensorsIn)
     {
-        details.emplace_back(sensorNames[i], thresholdValue, false, ioc);
+        sensorDetails.emplace(sensor, makeDetails(sensor->getName()));
     }
 }
 
-NumericThreshold::~NumericThreshold()
-{}
-
 void NumericThreshold::initialize()
 {
-    for (auto& sensor : sensors)
-    {
-        sensor->registerForUpdates(weak_from_this());
-    }
+    ThresholdOperations().initialize(this);
+}
+
+void NumericThreshold::updateSensors(Sensors newSensors)
+{
+    ThresholdOperations().updateSensors(this, std::move(newSensors));
 }
 
 NumericThreshold::ThresholdDetail&
-    NumericThreshold::getDetails(interfaces::Sensor& sensor)
+    NumericThreshold::getDetails(const interfaces::Sensor& sensor)
 {
-    auto it =
-        std::find_if(sensors.begin(), sensors.end(),
-                     [&sensor](const auto& x) { return &sensor == x.get(); });
-    auto index = std::distance(sensors.begin(), it);
-    return details.at(index);
+    return ThresholdOperations().getDetails(this, sensor);
+}
+
+std::shared_ptr<NumericThreshold::ThresholdDetail>
+    NumericThreshold::makeDetails(const std::string& sensorName)
+{
+    return std::make_shared<ThresholdDetail>(sensorName, thresholdValue, false,
+                                             ioc);
 }
 
 void NumericThreshold::sensorUpdated(interfaces::Sensor& sensor,
@@ -48,7 +47,8 @@
 void NumericThreshold::sensorUpdated(interfaces::Sensor& sensor,
                                      Milliseconds timestamp, double value)
 {
-    auto& [sensorName, prevValue, dwell, timer] = getDetails(sensor);
+    auto& details = getDetails(sensor);
+    auto& [sensorName, prevValue, dwell, timer] = details;
     bool decreasing = thresholdValue < prevValue && thresholdValue > value;
     bool increasing = thresholdValue > prevValue && thresholdValue < value;
 
@@ -61,16 +61,19 @@
         (direction == numeric::Direction::increasing && increasing) ||
         (direction == numeric::Direction::either && (increasing || decreasing)))
     {
-        startTimer(sensorName, timestamp, value, dwell, timer);
+        startTimer(details, timestamp, value);
     }
 
     prevValue = value;
 }
 
-void NumericThreshold::startTimer(const std::string& sensorName,
-                                  Milliseconds timestamp, double value,
-                                  bool& dwell, boost::asio::steady_timer& timer)
+void NumericThreshold::startTimer(NumericThreshold::ThresholdDetail& details,
+                                  Milliseconds timestamp, double value)
 {
+    const auto& sensorName = details.sensorName;
+    auto& dwell = details.dwell;
+    auto& timer = details.timer;
+
     if (dwellTime == Milliseconds::zero())
     {
         commit(sensorName, timestamp, value);
@@ -79,8 +82,8 @@
     {
         dwell = true;
         timer.expires_after(dwellTime);
-        timer.async_wait([this, sensorName, timestamp, value,
-                          &dwell](const boost::system::error_code ec) {
+        timer.async_wait([this, &sensorName, &dwell, timestamp,
+                          value](const boost::system::error_code ec) {
             if (ec)
             {
                 phosphor::logging::log<phosphor::logging::level::DEBUG>(
@@ -101,3 +104,9 @@
         action->commit(sensorName, timestamp, value);
     }
 }
+
+LabeledThresholdParam NumericThreshold::getThresholdParam() const
+{
+    return numeric::LabeledThresholdParam(type, dwellTime.count(), direction,
+                                          thresholdValue);
+}
diff --git a/src/numeric_threshold.hpp b/src/numeric_threshold.hpp
index 2aff15c..02480a4 100644
--- a/src/numeric_threshold.hpp
+++ b/src/numeric_threshold.hpp
@@ -6,10 +6,12 @@
 #include "interfaces/trigger_action.hpp"
 #include "types/duration_types.hpp"
 #include "types/trigger_types.hpp"
+#include "utils/threshold_operations.hpp"
 
 #include <boost/asio/steady_timer.hpp>
 
 #include <chrono>
+#include <map>
 #include <memory>
 #include <vector>
 
@@ -21,23 +23,26 @@
   public:
     NumericThreshold(
         boost::asio::io_context& ioc, Sensors sensors,
-        std::vector<std::string> sensorNames,
         std::vector<std::unique_ptr<interfaces::TriggerAction>> actions,
         Milliseconds dwellTime, numeric::Direction direction,
-        double thresholdValue);
-    ~NumericThreshold();
+        double thresholdValue, numeric::Type type);
+    ~NumericThreshold()
+    {}
 
     void initialize() override;
     void sensorUpdated(interfaces::Sensor&, Milliseconds) override;
     void sensorUpdated(interfaces::Sensor&, Milliseconds, double) override;
+    LabeledThresholdParam getThresholdParam() const override;
+    void updateSensors(Sensors newSensors) override;
 
   private:
     boost::asio::io_context& ioc;
-    const Sensors sensors;
     const std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
     const Milliseconds dwellTime;
     const numeric::Direction direction;
     const double thresholdValue;
+    const numeric::Type type;
+    bool initialized = false;
 
     struct ThresholdDetail
     {
@@ -52,10 +57,15 @@
             prevValue(prevValue), dwell(dwell), timer(ioc)
         {}
     };
-    std::vector<ThresholdDetail> details;
+    using SensorDetails =
+        std::unordered_map<std::shared_ptr<interfaces::Sensor>,
+                           std::shared_ptr<ThresholdDetail>>;
+    SensorDetails sensorDetails;
 
-    void startTimer(const std::string&, Milliseconds, double, bool&,
-                    boost::asio::steady_timer&);
+    friend ThresholdOperations;
+
+    void startTimer(ThresholdDetail&, Milliseconds, double);
     void commit(const std::string&, Milliseconds, double);
-    ThresholdDetail& getDetails(interfaces::Sensor& sensor);
+    ThresholdDetail& getDetails(const interfaces::Sensor& sensor);
+    std::shared_ptr<ThresholdDetail> makeDetails(const std::string& sensorName);
 };
diff --git a/src/on_change_threshold.cpp b/src/on_change_threshold.cpp
index e278c7f..fe3d1dd 100644
--- a/src/on_change_threshold.cpp
+++ b/src/on_change_threshold.cpp
@@ -3,10 +3,10 @@
 #include <phosphor-logging/log.hpp>
 
 OnChangeThreshold::OnChangeThreshold(
-    Sensors sensorsIn, std::vector<std::string> sensorNamesIn,
+    Sensors sensorsIn,
     std::vector<std::unique_ptr<interfaces::TriggerAction>> actionsIn) :
     sensors(std::move(sensorsIn)),
-    sensorNames(std::move(sensorNamesIn)), actions(std::move(actionsIn))
+    actions(std::move(actionsIn))
 {}
 
 void OnChangeThreshold::initialize()
@@ -15,6 +15,39 @@
     {
         sensor->registerForUpdates(weak_from_this());
     }
+    initialized = true;
+}
+
+void OnChangeThreshold::updateSensors(Sensors newSensors)
+{
+    Sensors oldSensors = sensors;
+
+    for (const auto& sensor : newSensors)
+    {
+        auto it =
+            std::find_if(oldSensors.begin(), oldSensors.end(),
+                         [&sensor](const auto& s) { return sensor == s; });
+        if (it != oldSensors.end())
+        {
+            oldSensors.erase(it);
+            continue;
+        }
+
+        if (initialized)
+        {
+            sensor->registerForUpdates(weak_from_this());
+        }
+    }
+
+    if (initialized)
+    {
+        for (auto& sensor : oldSensors)
+        {
+            sensor->unregisterFromUpdates(weak_from_this());
+        }
+    }
+
+    sensors = std::move(newSensors);
 }
 
 void OnChangeThreshold::sensorUpdated(interfaces::Sensor& sensor,
@@ -24,11 +57,7 @@
 void OnChangeThreshold::sensorUpdated(interfaces::Sensor& sensor,
                                       Milliseconds timestamp, double value)
 {
-    auto it =
-        std::find_if(sensors.begin(), sensors.end(),
-                     [&sensor](const auto& x) { return &sensor == x.get(); });
-    auto index = std::distance(sensors.begin(), it);
-    commit(sensorNames.at(index), timestamp, value);
+    commit(sensor.getName(), timestamp, value);
 }
 
 void OnChangeThreshold::commit(const std::string& sensorName,
@@ -39,3 +68,8 @@
         action->commit(sensorName, timestamp, value);
     }
 }
+
+LabeledThresholdParam OnChangeThreshold::getThresholdParam() const
+{
+    return {};
+}
diff --git a/src/on_change_threshold.hpp b/src/on_change_threshold.hpp
index 61c75d5..32a5f65 100644
--- a/src/on_change_threshold.hpp
+++ b/src/on_change_threshold.hpp
@@ -19,7 +19,7 @@
 {
   public:
     OnChangeThreshold(
-        Sensors sensors, std::vector<std::string> sensorNames,
+        Sensors sensors,
         std::vector<std::unique_ptr<interfaces::TriggerAction>> actions);
     ~OnChangeThreshold()
     {}
@@ -27,11 +27,13 @@
     void initialize() override;
     void sensorUpdated(interfaces::Sensor&, Milliseconds) override;
     void sensorUpdated(interfaces::Sensor&, Milliseconds, double) override;
+    LabeledThresholdParam getThresholdParam() const override;
+    void updateSensors(Sensors newSensors) override;
 
   private:
-    const Sensors sensors;
-    const std::vector<std::string> sensorNames;
+    Sensors sensors;
     const std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
+    bool initialized = false;
 
     void commit(const std::string&, Milliseconds, double);
 };
diff --git a/src/report_factory.cpp b/src/report_factory.cpp
index 952b4f2..df71fa0 100644
--- a/src/report_factory.cpp
+++ b/src/report_factory.cpp
@@ -47,13 +47,13 @@
 }
 
 Sensors ReportFactory::getSensors(
-    const std::vector<LabeledSensorParameters>& sensorPaths) const
+    const std::vector<LabeledSensorInfo>& sensorPaths) const
 {
     using namespace utils::tstring;
 
     return utils::transform(
         sensorPaths,
-        [this](const LabeledSensorParameters& sensorPath)
+        [this](const LabeledSensorInfo& sensorPath)
             -> std::shared_ptr<interfaces::Sensor> {
             return sensorCache.makeSensor<Sensor>(
                 sensorPath.at_label<Service>(), sensorPath.at_label<Path>(),
@@ -71,7 +71,7 @@
         auto [sensorPaths, operationType, id, collectionTimeScope,
               collectionDuration] = item;
 
-        std::vector<LabeledSensorParameters> sensorParameters;
+        std::vector<LabeledSensorInfo> sensorParameters;
 
         for (const auto& [sensorPath, metadata] : sensorPaths)
         {
diff --git a/src/report_factory.hpp b/src/report_factory.hpp
index c9209ef..14f9f39 100644
--- a/src/report_factory.hpp
+++ b/src/report_factory.hpp
@@ -3,6 +3,7 @@
 #include "interfaces/report_factory.hpp"
 #include "interfaces/sensor.hpp"
 #include "sensor_cache.hpp"
+#include "types/sensor_types.hpp"
 
 #include <boost/asio/io_context.hpp>
 #include <sdbusplus/asio/object_server.hpp>
@@ -31,8 +32,7 @@
              bool enabled) const override;
 
   private:
-    Sensors getSensors(
-        const std::vector<LabeledSensorParameters>& sensorPaths) const;
+    Sensors getSensors(const std::vector<LabeledSensorInfo>& sensorPaths) const;
 
     std::shared_ptr<sdbusplus::asio::connection> bus;
     std::shared_ptr<sdbusplus::asio::object_server> objServer;
diff --git a/src/sensor.cpp b/src/sensor.cpp
index d81e1a1..2551562 100644
--- a/src/sensor.cpp
+++ b/src/sensor.cpp
@@ -30,6 +30,11 @@
     return sensorMetadata;
 }
 
+std::string Sensor::getName() const
+{
+    return sensorMetadata.empty() ? sensorId.path : sensorMetadata;
+}
+
 void Sensor::async_read()
 {
     uniqueCall([this](auto lock) { async_read(std::move(lock)); });
@@ -179,3 +184,8 @@
         }
     }
 }
+
+LabeledSensorInfo Sensor::getLabeledSensorInfo() const
+{
+    return LabeledSensorInfo(sensorId.service, sensorId.path, sensorMetadata);
+}
diff --git a/src/sensor.hpp b/src/sensor.hpp
index d2c3ec2..92ff02c 100644
--- a/src/sensor.hpp
+++ b/src/sensor.hpp
@@ -29,11 +29,14 @@
 
     Id id() const override;
     std::string metadata() const override;
+    std::string getName() const override;
     void registerForUpdates(
         const std::weak_ptr<interfaces::SensorListener>& weakListener) override;
     void unregisterFromUpdates(
         const std::weak_ptr<interfaces::SensorListener>& weakListener) override;
 
+    LabeledSensorInfo getLabeledSensorInfo() const override;
+
   private:
     static std::optional<double> readValue(const ValueVariant& v);
     static void signalProc(const std::weak_ptr<Sensor>& weakSelf,
diff --git a/src/trigger.cpp b/src/trigger.cpp
index e84a389..db988ff 100644
--- a/src/trigger.cpp
+++ b/src/trigger.cpp
@@ -12,21 +12,18 @@
     boost::asio::io_context& ioc,
     const std::shared_ptr<sdbusplus::asio::object_server>& objServer,
     const std::string& idIn, const std::string& nameIn,
-    const std::vector<std::string>& triggerActionsIn,
-    const std::vector<std::string>& reportIdsIn,
-    const std::vector<LabeledSensorInfo>& LabeledSensorsInfoIn,
-    const LabeledTriggerThresholdParams& labeledThresholdParamsIn,
+    const std::vector<TriggerAction>& triggerActionsIn,
+    const std::shared_ptr<std::vector<std::string>> reportIdsIn,
     std::vector<std::shared_ptr<interfaces::Threshold>>&& thresholdsIn,
     interfaces::TriggerManager& triggerManager,
-    interfaces::JsonStorage& triggerStorageIn) :
+    interfaces::JsonStorage& triggerStorageIn,
+    const interfaces::TriggerFactory& triggerFactory, Sensors sensorsIn) :
     id(idIn),
     name(nameIn), triggerActions(std::move(triggerActionsIn)),
-    path(triggerDir + id), reportIds(reportIdsIn),
-    labeledSensorsInfo(LabeledSensorsInfoIn),
-    labeledThresholdParams(labeledThresholdParamsIn),
+    path(triggerDir + id), reportIds(std::move(reportIdsIn)),
     thresholds(std::move(thresholdsIn)),
     fileName(std::to_string(std::hash<std::string>{}(id))),
-    triggerStorage(triggerStorageIn)
+    triggerStorage(triggerStorageIn), sensors(std::move(sensorsIn))
 {
     deleteIface = objServer->add_unique_interface(
         path, deleteIfaceName, [this, &ioc, &triggerManager](auto& dbusIface) {
@@ -42,7 +39,7 @@
         });
 
     triggerIface = objServer->add_unique_interface(
-        path, triggerIfaceName, [this](auto& dbusIface) {
+        path, triggerIfaceName, [this, &triggerFactory](auto& dbusIface) {
             persistent = storeConfiguration();
             dbusIface.register_property_rw(
                 "Persistent", persistent,
@@ -65,31 +62,64 @@
                 },
                 [this](const auto&) { return persistent; });
 
-            dbusIface.register_property_r(
+            dbusIface.register_property_rw(
                 "Thresholds", TriggerThresholdParams{},
                 sdbusplus::vtable::property_::emits_change,
+                [this, &triggerFactory](auto newVal, auto& oldVal) {
+                    auto newThresholdParams = std::visit(
+                        utils::ToLabeledThresholdParamConversion(), newVal);
+                    triggerFactory.updateThresholds(thresholds, triggerActions,
+                                                    reportIds, sensors,
+                                                    newThresholdParams);
+                    oldVal = std::move(newVal);
+                    return 1;
+                },
                 [this](const auto&) {
-                    return std::visit(
-                        utils::FromLabeledThresholdParamConversion(),
-                        labeledThresholdParams);
+                    return fromLabeledThresholdParam(
+                        utils::transform(thresholds, [](const auto& threshold) {
+                            return threshold->getThresholdParam();
+                        }));
                 });
 
-            dbusIface.register_property_r(
+            dbusIface.register_property_rw(
                 "Sensors", SensorsInfo{},
                 sdbusplus::vtable::property_::emits_change,
+                [this, &triggerFactory](auto newVal, auto& oldVal) {
+                    auto labeledSensorInfo =
+                        triggerFactory.getLabeledSensorsInfo(newVal);
+                    triggerFactory.updateSensors(sensors, labeledSensorInfo);
+                    for (const auto& threshold : thresholds)
+                    {
+                        threshold->updateSensors(sensors);
+                    }
+                    oldVal = std::move(newVal);
+                    return 1;
+                },
                 [this](const auto&) {
-                    return utils::fromLabeledSensorsInfo(labeledSensorsInfo);
+                    return utils::fromLabeledSensorsInfo(
+                        utils::transform(sensors, [](const auto& sensor) {
+                            return sensor->getLabeledSensorInfo();
+                        }));
                 });
 
-            dbusIface.register_property_r(
-                "ReportNames", reportIds,
+            dbusIface.register_property_rw(
+                "ReportNames", std::vector<std::string>{},
                 sdbusplus::vtable::property_::emits_change,
-                [](const auto& x) { return x; });
+                [this](auto newVal, auto& oldVal) {
+                    reportIds->clear();
+                    std::copy(newVal.begin(), newVal.end(),
+                              std::back_inserter(*reportIds));
+                    oldVal = std::move(newVal);
+                    return 1;
+                },
+                [this](const auto&) { return *reportIds; });
 
             dbusIface.register_property_r(
                 "Discrete", false, sdbusplus::vtable::property_::const_,
                 [this](const auto& x) {
-                    return isTriggerThresholdDiscrete(labeledThresholdParams);
+                    return !std::holds_alternative<
+                        numeric::LabeledThresholdParam>(
+                        thresholds.back()->getThresholdParam());
                 });
 
             dbusIface.register_property_rw(
@@ -101,9 +131,14 @@
                 },
                 [this](const auto&) { return name; });
 
-            dbusIface.register_property_r("TriggerActions", triggerActions,
-                                          sdbusplus::vtable::property_::const_,
-                                          [this](const auto& x) { return x; });
+            dbusIface.register_property_r(
+                "TriggerActions", std::vector<std::string>(),
+                sdbusplus::vtable::property_::const_, [this](const auto&) {
+                    return utils::transform(triggerActions,
+                                            [](const auto& action) {
+                                                return actionToString(action);
+                                            });
+                });
         });
 
     for (const auto& threshold : thresholds)
@@ -118,15 +153,27 @@
     {
         nlohmann::json data;
 
+        auto labeledThresholdParams =
+            std::visit(utils::ToLabeledThresholdParamConversion(),
+                       fromLabeledThresholdParam(utils::transform(
+                           thresholds, [](const auto& threshold) {
+                               return threshold->getThresholdParam();
+                           })));
+
         data["Version"] = triggerVersion;
         data["Id"] = id;
         data["Name"] = name;
         data["ThresholdParamsDiscriminator"] = labeledThresholdParams.index();
-        data["TriggerActions"] = triggerActions;
+        data["TriggerActions"] =
+            utils::transform(triggerActions, [](const auto& action) {
+                return actionToString(action);
+            });
         data["ThresholdParams"] =
             utils::labeledThresholdParamsToJson(labeledThresholdParams);
-        data["ReportIds"] = reportIds;
-        data["Sensors"] = labeledSensorsInfo;
+        data["ReportIds"] = *reportIds;
+        data["Sensors"] = utils::transform(sensors, [](const auto& sensor) {
+            return sensor->getLabeledSensorInfo();
+        });
 
         triggerStorage.store(fileName, data);
     }
diff --git a/src/trigger.hpp b/src/trigger.hpp
index 54f67c5..a9348bd 100644
--- a/src/trigger.hpp
+++ b/src/trigger.hpp
@@ -3,6 +3,7 @@
 #include "interfaces/json_storage.hpp"
 #include "interfaces/threshold.hpp"
 #include "interfaces/trigger.hpp"
+#include "interfaces/trigger_factory.hpp"
 #include "interfaces/trigger_manager.hpp"
 #include "types/trigger_types.hpp"
 
@@ -17,13 +18,13 @@
     Trigger(boost::asio::io_context& ioc,
             const std::shared_ptr<sdbusplus::asio::object_server>& objServer,
             const std::string& id, const std::string& name,
-            const std::vector<std::string>& triggerActions,
-            const std::vector<std::string>& reportIds,
-            const std::vector<LabeledSensorInfo>& LabeledSensorsInfoIn,
-            const LabeledTriggerThresholdParams& labeledThresholdParamsIn,
+            const std::vector<TriggerAction>& triggerActions,
+            const std::shared_ptr<std::vector<std::string>> reportIds,
             std::vector<std::shared_ptr<interfaces::Threshold>>&& thresholds,
             interfaces::TriggerManager& triggerManager,
-            interfaces::JsonStorage& triggerStorage);
+            interfaces::JsonStorage& triggerStorage,
+            const interfaces::TriggerFactory& triggerFactory,
+            Sensors sensorsIn);
 
     Trigger(const Trigger&) = delete;
     Trigger(Trigger&&) = delete;
@@ -45,18 +46,17 @@
   private:
     std::string id;
     std::string name;
-    std::vector<std::string> triggerActions;
+    std::vector<TriggerAction> triggerActions;
     std::string path;
     bool persistent = false;
-    std::vector<std::string> reportIds;
-    std::vector<LabeledSensorInfo> labeledSensorsInfo;
-    LabeledTriggerThresholdParams labeledThresholdParams;
+    std::shared_ptr<std::vector<std::string>> reportIds;
     std::unique_ptr<sdbusplus::asio::dbus_interface> deleteIface;
     std::unique_ptr<sdbusplus::asio::dbus_interface> triggerIface;
     std::vector<std::shared_ptr<interfaces::Threshold>> thresholds;
 
     interfaces::JsonStorage::FilePath fileName;
     interfaces::JsonStorage& triggerStorage;
+    Sensors sensors;
 
   public:
     static constexpr const char* triggerIfaceName =
@@ -65,5 +65,5 @@
         "/xyz/openbmc_project/Telemetry/Triggers/";
     static constexpr const char* deleteIfaceName =
         "xyz.openbmc_project.Object.Delete";
-    static constexpr size_t triggerVersion = 0;
+    static constexpr size_t triggerVersion = 1;
 };
diff --git a/src/trigger_actions.cpp b/src/trigger_actions.cpp
index 22c81a3..0a627e6 100644
--- a/src/trigger_actions.cpp
+++ b/src/trigger_actions.cpp
@@ -99,7 +99,7 @@
     std::vector<std::unique_ptr<interfaces::TriggerAction>>& actionsIf,
     const std::vector<TriggerAction>& ActionsEnum, ::numeric::Type type,
     double thresholdValue, interfaces::ReportManager& reportManager,
-    const std::vector<std::string>& reportIds)
+    const std::shared_ptr<std::vector<std::string>>& reportIds)
 {
     actionsIf.reserve(ActionsEnum.size());
     for (auto actionType : ActionsEnum)
@@ -185,7 +185,7 @@
     std::vector<std::unique_ptr<interfaces::TriggerAction>>& actionsIf,
     const std::vector<TriggerAction>& ActionsEnum,
     ::discrete::Severity severity, interfaces::ReportManager& reportManager,
-    const std::vector<std::string>& reportIds)
+    const std::shared_ptr<std::vector<std::string>>& reportIds)
 {
     actionsIf.reserve(ActionsEnum.size());
     for (auto actionType : ActionsEnum)
@@ -241,7 +241,7 @@
     std::vector<std::unique_ptr<interfaces::TriggerAction>>& actionsIf,
     const std::vector<TriggerAction>& ActionsEnum,
     interfaces::ReportManager& reportManager,
-    const std::vector<std::string>& reportIds)
+    const std::shared_ptr<std::vector<std::string>>& reportIds)
 {
     actionsIf.reserve(ActionsEnum.size());
     for (auto actionType : ActionsEnum)
@@ -272,7 +272,7 @@
 
 void UpdateReport::commit(const std::string&, Milliseconds, double)
 {
-    for (const auto& name : reportIds)
+    for (const auto& name : *reportIds)
     {
         reportManager.updateReport(name);
     }
diff --git a/src/trigger_actions.hpp b/src/trigger_actions.hpp
index 6a5f7c2..99a1baa 100644
--- a/src/trigger_actions.hpp
+++ b/src/trigger_actions.hpp
@@ -45,7 +45,7 @@
     std::vector<std::unique_ptr<interfaces::TriggerAction>>& actionsIf,
     const std::vector<TriggerAction>& ActionsEnum, ::numeric::Type type,
     double thresholdValue, interfaces::ReportManager& reportManager,
-    const std::vector<std::string>& reportIds);
+    const std::shared_ptr<std::vector<std::string>>& reportIds);
 } // namespace numeric
 
 namespace discrete
@@ -84,7 +84,7 @@
     std::vector<std::unique_ptr<interfaces::TriggerAction>>& actionsIf,
     const std::vector<TriggerAction>& ActionsEnum,
     ::discrete::Severity severity, interfaces::ReportManager& reportManager,
-    const std::vector<std::string>& reportIds);
+    const std::shared_ptr<std::vector<std::string>>& reportIds);
 
 namespace onChange
 {
@@ -112,7 +112,7 @@
     std::vector<std::unique_ptr<interfaces::TriggerAction>>& actionsIf,
     const std::vector<TriggerAction>& ActionsEnum,
     interfaces::ReportManager& reportManager,
-    const std::vector<std::string>& reportIds);
+    const std::shared_ptr<std::vector<std::string>>& reportIds);
 } // namespace onChange
 
 } // namespace discrete
@@ -121,7 +121,7 @@
 {
   public:
     UpdateReport(interfaces::ReportManager& reportManager,
-                 std::vector<std::string> ids) :
+                 std::shared_ptr<std::vector<std::string>> ids) :
         reportManager(reportManager),
         reportIds(std::move(ids))
     {}
@@ -131,6 +131,6 @@
 
   private:
     interfaces::ReportManager& reportManager;
-    std::vector<std::string> reportIds;
+    std::shared_ptr<std::vector<std::string>> reportIds;
 };
 } // namespace action
diff --git a/src/trigger_factory.cpp b/src/trigger_factory.cpp
index 493fe32..c8b464e 100644
--- a/src/trigger_factory.cpp
+++ b/src/trigger_factory.cpp
@@ -20,126 +20,284 @@
     reportManager(reportManager)
 {}
 
+void TriggerFactory::updateDiscreteThresholds(
+    std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+    const std::vector<TriggerAction>& triggerActions,
+    const std::shared_ptr<std::vector<std::string>>& reportIds,
+    const Sensors& sensors,
+    const std::vector<discrete::LabeledThresholdParam>& newParams) const
+{
+    auto oldThresholds = currentThresholds;
+    std::vector<std::shared_ptr<interfaces::Threshold>> newThresholds;
+
+    bool isCurrentOnChange = false;
+    if (oldThresholds.size() == 1 &&
+        std::holds_alternative<std::monostate>(
+            oldThresholds.back()->getThresholdParam()))
+    {
+        isCurrentOnChange = true;
+    }
+
+    newThresholds.reserve(newParams.size());
+
+    if (!isCurrentOnChange)
+    {
+        for (const auto& labeledThresholdParam : newParams)
+        {
+            auto paramChecker = [labeledThresholdParam](auto threshold) {
+                return labeledThresholdParam ==
+                       std::get<discrete::LabeledThresholdParam>(
+                           threshold->getThresholdParam());
+            };
+            if (auto existing = std::find_if(oldThresholds.begin(),
+                                             oldThresholds.end(), paramChecker);
+                existing != oldThresholds.end())
+            {
+                newThresholds.emplace_back(*existing);
+                oldThresholds.erase(existing);
+                continue;
+            }
+
+            makeDiscreteThreshold(newThresholds, triggerActions, reportIds,
+                                  sensors, labeledThresholdParam);
+        }
+    }
+    else
+    {
+        for (const auto& labeledThresholdParam : newParams)
+        {
+            makeDiscreteThreshold(newThresholds, triggerActions, reportIds,
+                                  sensors, labeledThresholdParam);
+        }
+    }
+    if (newParams.empty())
+    {
+        if (isCurrentOnChange)
+        {
+            newThresholds.emplace_back(*oldThresholds.begin());
+        }
+        else
+        {
+            makeOnChangeThreshold(newThresholds, triggerActions, reportIds,
+                                  sensors);
+        }
+    }
+    currentThresholds = std::move(newThresholds);
+}
+
+void TriggerFactory::updateNumericThresholds(
+    std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+    const std::vector<TriggerAction>& triggerActions,
+    const std::shared_ptr<std::vector<std::string>>& reportIds,
+    const Sensors& sensors,
+    const std::vector<numeric::LabeledThresholdParam>& newParams) const
+{
+    auto oldThresholds = currentThresholds;
+    std::vector<std::shared_ptr<interfaces::Threshold>> newThresholds;
+
+    newThresholds.reserve(newParams.size());
+
+    for (const auto& labeledThresholdParam : newParams)
+    {
+        auto paramChecker = [labeledThresholdParam](auto threshold) {
+            return labeledThresholdParam ==
+                   std::get<numeric::LabeledThresholdParam>(
+                       threshold->getThresholdParam());
+        };
+        if (auto existing = std::find_if(oldThresholds.begin(),
+                                         oldThresholds.end(), paramChecker);
+            existing != oldThresholds.end())
+        {
+            newThresholds.emplace_back(*existing);
+            oldThresholds.erase(existing);
+            continue;
+        }
+
+        makeNumericThreshold(newThresholds, triggerActions, reportIds, sensors,
+                             labeledThresholdParam);
+    }
+    currentThresholds = std::move(newThresholds);
+}
+
+void TriggerFactory::updateThresholds(
+    std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+    const std::vector<TriggerAction>& triggerActions,
+    const std::shared_ptr<std::vector<std::string>>& reportIds,
+    const Sensors& sensors,
+    const LabeledTriggerThresholdParams& newParams) const
+{
+    if (isTriggerThresholdDiscrete(newParams))
+    {
+        const auto& labeledDiscreteThresholdParams =
+            std::get<std::vector<discrete::LabeledThresholdParam>>(newParams);
+
+        updateDiscreteThresholds(currentThresholds, triggerActions, reportIds,
+                                 sensors, labeledDiscreteThresholdParams);
+    }
+    else
+    {
+        const auto& labeledNumericThresholdParams =
+            std::get<std::vector<numeric::LabeledThresholdParam>>(newParams);
+
+        updateNumericThresholds(currentThresholds, triggerActions, reportIds,
+                                sensors, labeledNumericThresholdParams);
+    }
+}
+
+void TriggerFactory::makeDiscreteThreshold(
+    std::vector<std::shared_ptr<interfaces::Threshold>>& thresholds,
+    const std::vector<TriggerAction>& triggerActions,
+    const std::shared_ptr<std::vector<std::string>>& reportIds,
+    const Sensors& sensors,
+    const discrete::LabeledThresholdParam& thresholdParam) const
+{
+    std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
+
+    std::string thresholdName = thresholdParam.at_label<ts::UserId>();
+    discrete::Severity severity = thresholdParam.at_label<ts::Severity>();
+    auto dwellTime = Milliseconds(thresholdParam.at_label<ts::DwellTime>());
+    std::string thresholdValue = thresholdParam.at_label<ts::ThresholdValue>();
+
+    action::discrete::fillActions(actions, triggerActions, severity,
+                                  reportManager, reportIds);
+
+    thresholds.emplace_back(std::make_shared<DiscreteThreshold>(
+        bus->get_io_context(), sensors, std::move(actions),
+        Milliseconds(dwellTime), std::stod(thresholdValue), thresholdName,
+        severity));
+}
+
+void TriggerFactory::makeNumericThreshold(
+    std::vector<std::shared_ptr<interfaces::Threshold>>& thresholds,
+    const std::vector<TriggerAction>& triggerActions,
+    const std::shared_ptr<std::vector<std::string>>& reportIds,
+    const Sensors& sensors,
+    const numeric::LabeledThresholdParam& thresholdParam) const
+{
+    std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
+
+    auto type = thresholdParam.at_label<ts::Type>();
+    auto dwellTime = Milliseconds(thresholdParam.at_label<ts::DwellTime>());
+    auto direction = thresholdParam.at_label<ts::Direction>();
+    auto thresholdValue = double{thresholdParam.at_label<ts::ThresholdValue>()};
+
+    action::numeric::fillActions(actions, triggerActions, type, thresholdValue,
+                                 reportManager, reportIds);
+
+    thresholds.emplace_back(std::make_shared<NumericThreshold>(
+        bus->get_io_context(), sensors, std::move(actions), dwellTime,
+        direction, thresholdValue, type));
+}
+
+void TriggerFactory::makeOnChangeThreshold(
+    std::vector<std::shared_ptr<interfaces::Threshold>>& thresholds,
+    const std::vector<TriggerAction>& triggerActions,
+    const std::shared_ptr<std::vector<std::string>>& reportIds,
+    const Sensors& sensors) const
+{
+    std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
+
+    action::discrete::onChange::fillActions(actions, triggerActions,
+                                            reportManager, reportIds);
+
+    thresholds.emplace_back(
+        std::make_shared<OnChangeThreshold>(sensors, std::move(actions)));
+}
+
 std::unique_ptr<interfaces::Trigger> TriggerFactory::make(
     const std::string& id, const std::string& name,
     const std::vector<std::string>& triggerActionsIn,
-    const std::vector<std::string>& reportIds,
+    const std::vector<std::string>& reportIdsIn,
     interfaces::TriggerManager& triggerManager,
     interfaces::JsonStorage& triggerStorage,
     const LabeledTriggerThresholdParams& labeledThresholdParams,
     const std::vector<LabeledSensorInfo>& labeledSensorsInfo) const
 {
-    const auto& [sensors, sensorNames] = getSensors(labeledSensorsInfo);
-    std::vector<TriggerAction> triggerActions;
-    std::transform(triggerActionsIn.begin(), triggerActionsIn.end(),
-                   std::back_inserter(triggerActions),
-                   [](const auto& triggerActionStr) {
-                       return toTriggerAction(triggerActionStr);
-                   });
+    const auto& sensors = getSensors(labeledSensorsInfo);
+    auto triggerActions =
+        utils::transform(triggerActionsIn, [](const auto& triggerActionStr) {
+            return toTriggerAction(triggerActionStr);
+        });
     std::vector<std::shared_ptr<interfaces::Threshold>> thresholds;
 
-    if (isTriggerThresholdDiscrete(labeledThresholdParams))
-    {
-        const auto& labeledDiscreteThresholdParams =
-            std::get<std::vector<discrete::LabeledThresholdParam>>(
-                labeledThresholdParams);
-        for (const auto& labeledThresholdParam : labeledDiscreteThresholdParams)
-        {
-            std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
+    auto reportIds = std::make_shared<std::vector<std::string>>(reportIdsIn);
 
-            std::string thresholdName =
-                labeledThresholdParam.at_label<ts::UserId>();
-            discrete::Severity severity =
-                labeledThresholdParam.at_label<ts::Severity>();
-            auto dwellTime =
-                Milliseconds(labeledThresholdParam.at_label<ts::DwellTime>());
-            std::string thresholdValue =
-                labeledThresholdParam.at_label<ts::ThresholdValue>();
-
-            action::discrete::fillActions(actions, triggerActions, severity,
-                                          reportManager, reportIds);
-
-            thresholds.emplace_back(std::make_shared<DiscreteThreshold>(
-                bus->get_io_context(), sensors, sensorNames, std::move(actions),
-                Milliseconds(dwellTime), std::stod(thresholdValue),
-                thresholdName));
-        }
-        if (labeledDiscreteThresholdParams.empty())
-        {
-            std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
-            action::discrete::onChange::fillActions(actions, triggerActions,
-                                                    reportManager, reportIds);
-
-            thresholds.emplace_back(std::make_shared<OnChangeThreshold>(
-                sensors, sensorNames, std::move(actions)));
-        }
-    }
-    else
-    {
-        const auto& labeledNumericThresholdParams =
-            std::get<std::vector<numeric::LabeledThresholdParam>>(
-                labeledThresholdParams);
-
-        for (const auto& labeledThresholdParam : labeledNumericThresholdParams)
-        {
-            std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
-            auto type = labeledThresholdParam.at_label<ts::Type>();
-            auto dwellTime =
-                Milliseconds(labeledThresholdParam.at_label<ts::DwellTime>());
-            auto direction = labeledThresholdParam.at_label<ts::Direction>();
-            auto thresholdValue =
-                double{labeledThresholdParam.at_label<ts::ThresholdValue>()};
-
-            action::numeric::fillActions(actions, triggerActions, type,
-                                         thresholdValue, reportManager,
-                                         reportIds);
-
-            thresholds.emplace_back(std::make_shared<NumericThreshold>(
-                bus->get_io_context(), sensors, sensorNames, std::move(actions),
-                dwellTime, direction, thresholdValue));
-        }
-    }
+    updateThresholds(thresholds, triggerActions, reportIds, sensors,
+                     labeledThresholdParams);
 
     return std::make_unique<Trigger>(
-        bus->get_io_context(), objServer, id, name, triggerActionsIn, reportIds,
-        labeledSensorsInfo, labeledThresholdParams, std::move(thresholds),
-        triggerManager, triggerStorage);
+        bus->get_io_context(), objServer, id, name, triggerActions, reportIds,
+        std::move(thresholds), triggerManager, triggerStorage, *this, sensors);
 }
 
-std::pair<Sensors, std::vector<std::string>> TriggerFactory::getSensors(
+Sensors TriggerFactory::getSensors(
     const std::vector<LabeledSensorInfo>& labeledSensorsInfo) const
 {
     Sensors sensors;
-    std::vector<std::string> sensorNames;
+    updateSensors(sensors, labeledSensorsInfo);
+    return sensors;
+}
+
+void TriggerFactory::updateSensors(
+    Sensors& currentSensors,
+    const std::vector<LabeledSensorInfo>& labeledSensorsInfo) const
+{
+    Sensors oldSensors = currentSensors;
+    Sensors newSensors;
 
     for (const auto& labeledSensorInfo : labeledSensorsInfo)
     {
+        auto existing = std::find_if(oldSensors.begin(), oldSensors.end(),
+                                     [labeledSensorInfo](auto sensor) {
+                                         return labeledSensorInfo ==
+                                                sensor->getLabeledSensorInfo();
+                                     });
+
+        if (existing != oldSensors.end())
+        {
+            newSensors.emplace_back(*existing);
+            oldSensors.erase(existing);
+            continue;
+        }
+
         const auto& service = labeledSensorInfo.at_label<ts::Service>();
-        const auto& sensorPath = labeledSensorInfo.at_label<ts::SensorPath>();
+        const auto& sensorPath = labeledSensorInfo.at_label<ts::Path>();
         const auto& metadata = labeledSensorInfo.at_label<ts::Metadata>();
 
-        sensors.emplace_back(sensorCache.makeSensor<Sensor>(
+        newSensors.emplace_back(sensorCache.makeSensor<Sensor>(
             service, sensorPath, metadata, bus->get_io_context(), bus));
-
-        if (metadata.empty())
-        {
-            sensorNames.emplace_back(sensorPath);
-        }
-        else
-        {
-            sensorNames.emplace_back(metadata);
-        }
     }
 
-    return {sensors, sensorNames};
+    currentSensors = std::move(newSensors);
 }
 
 std::vector<LabeledSensorInfo>
     TriggerFactory::getLabeledSensorsInfo(boost::asio::yield_context& yield,
                                           const SensorsInfo& sensorsInfo) const
 {
+    if (sensorsInfo.empty())
+    {
+        return {};
+    }
     auto tree = utils::getSubTreeSensors(yield, bus);
+    return parseSensorTree(tree, sensorsInfo);
+}
 
+std::vector<LabeledSensorInfo>
+    TriggerFactory::getLabeledSensorsInfo(const SensorsInfo& sensorsInfo) const
+{
+    if (sensorsInfo.empty())
+    {
+        return {};
+    }
+    auto tree = utils::getSubTreeSensors(bus);
+    return parseSensorTree(tree, sensorsInfo);
+}
+
+std::vector<LabeledSensorInfo>
+    TriggerFactory::parseSensorTree(const std::vector<utils::SensorTree>& tree,
+                                    const SensorsInfo& sensorsInfo)
+{
     return utils::transform(sensorsInfo, [&tree](const auto& item) {
         const auto& [sensorPath, metadata] = item;
         auto found = std::find_if(
diff --git a/src/trigger_factory.hpp b/src/trigger_factory.hpp
index 494f5ab..223efe0 100644
--- a/src/trigger_factory.hpp
+++ b/src/trigger_factory.hpp
@@ -2,8 +2,10 @@
 
 #include "interfaces/report_manager.hpp"
 #include "interfaces/sensor.hpp"
+#include "interfaces/threshold.hpp"
 #include "interfaces/trigger_factory.hpp"
 #include "sensor_cache.hpp"
+#include "utils/dbus_mapper.hpp"
 
 #include <sdbusplus/asio/object_server.hpp>
 
@@ -28,6 +30,19 @@
     std::vector<LabeledSensorInfo>
         getLabeledSensorsInfo(boost::asio::yield_context& yield,
                               const SensorsInfo& sensorsInfo) const override;
+    std::vector<LabeledSensorInfo>
+        getLabeledSensorsInfo(const SensorsInfo& sensorsInfo) const override;
+
+    void updateThresholds(
+        std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+        const std::vector<TriggerAction>& triggerActions,
+        const std::shared_ptr<std::vector<std::string>>& reportIds,
+        const Sensors& sensors,
+        const LabeledTriggerThresholdParams& newParams) const override;
+
+    void updateSensors(Sensors& currentSensors,
+                       const std::vector<LabeledSensorInfo>& labeledSensorsInfo)
+        const override;
 
   private:
     std::shared_ptr<sdbusplus::asio::connection> bus;
@@ -35,6 +50,44 @@
     SensorCache& sensorCache;
     interfaces::ReportManager& reportManager;
 
-    std::pair<Sensors, std::vector<std::string>> getSensors(
+    Sensors getSensors(
         const std::vector<LabeledSensorInfo>& labeledSensorsInfo) const;
+
+    static std::vector<LabeledSensorInfo>
+        parseSensorTree(const std::vector<utils::SensorTree>& tree,
+                        const SensorsInfo& sensorsInfo);
+
+    void updateDiscreteThresholds(
+        std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+        const std::vector<TriggerAction>& triggerActions,
+        const std::shared_ptr<std::vector<std::string>>& reportIds,
+        const Sensors& sensors,
+        const std::vector<discrete::LabeledThresholdParam>& newParams) const;
+
+    void updateNumericThresholds(
+        std::vector<std::shared_ptr<interfaces::Threshold>>& currentThresholds,
+        const std::vector<TriggerAction>& triggerActions,
+        const std::shared_ptr<std::vector<std::string>>& reportIds,
+        const Sensors& sensors,
+        const std::vector<numeric::LabeledThresholdParam>& newParams) const;
+
+    void makeDiscreteThreshold(
+        std::vector<std::shared_ptr<interfaces::Threshold>>& thresholds,
+        const std::vector<TriggerAction>& triggerActions,
+        const std::shared_ptr<std::vector<std::string>>& reportIds,
+        const Sensors& sensors,
+        const discrete::LabeledThresholdParam& thresholdParam) const;
+
+    void makeNumericThreshold(
+        std::vector<std::shared_ptr<interfaces::Threshold>>& thresholds,
+        const std::vector<TriggerAction>& triggerActions,
+        const std::shared_ptr<std::vector<std::string>>& reportIds,
+        const Sensors& sensors,
+        const numeric::LabeledThresholdParam& thresholdParam) const;
+
+    void makeOnChangeThreshold(
+        std::vector<std::shared_ptr<interfaces::Threshold>>& thresholds,
+        const std::vector<TriggerAction>& triggerActions,
+        const std::shared_ptr<std::vector<std::string>>& reportIds,
+        const Sensors& sensors) const;
 };
diff --git a/src/types/report_types.cpp b/src/types/report_types.cpp
index 47add24..72bce4b 100644
--- a/src/types/report_types.cpp
+++ b/src/types/report_types.cpp
@@ -12,7 +12,7 @@
             return ReadingParameters::value_type(
                 utils::transform(
                     metricParams.at_label<ts::SensorPath>(),
-                    [](const LabeledSensorParameters& sensorParameters) {
+                    [](const LabeledSensorInfo& sensorParameters) {
                         return std::tuple<sdbusplus::message::object_path,
                                           std::string>(
                             sensorParameters.at_label<ts::Path>(),
diff --git a/src/types/report_types.hpp b/src/types/report_types.hpp
index 978fd18..c0f7b39 100644
--- a/src/types/report_types.hpp
+++ b/src/types/report_types.hpp
@@ -3,6 +3,7 @@
 #include "types/collection_duration.hpp"
 #include "types/collection_time_scope.hpp"
 #include "types/operation_type.hpp"
+#include "types/sensor_types.hpp"
 #include "utils/labeled_tuple.hpp"
 #include "utils/tstring.hpp"
 
@@ -22,13 +23,8 @@
     std::vector<std::tuple<sdbusplus::message::object_path, std::string>>,
     std::string, std::string, std::string, uint64_t>>;
 
-using LabeledSensorParameters =
-    utils::LabeledTuple<std::tuple<std::string, std::string, std::string>,
-                        utils::tstring::Service, utils::tstring::Path,
-                        utils::tstring::Metadata>;
-
 using LabeledMetricParameters = utils::LabeledTuple<
-    std::tuple<std::vector<LabeledSensorParameters>, OperationType, std::string,
+    std::tuple<std::vector<LabeledSensorInfo>, OperationType, std::string,
                CollectionTimeScope, CollectionDuration>,
     utils::tstring::SensorPath, utils::tstring::OperationType,
     utils::tstring::Id, utils::tstring::CollectionTimeScope,
diff --git a/src/types/sensor_types.hpp b/src/types/sensor_types.hpp
new file mode 100644
index 0000000..e76b345
--- /dev/null
+++ b/src/types/sensor_types.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "utils/labeled_tuple.hpp"
+#include "utils/tstring.hpp"
+
+#include <tuple>
+#include <vector>
+
+using SensorsInfo =
+    std::vector<std::pair<sdbusplus::message::object_path, std::string>>;
+
+using LabeledSensorInfo =
+    utils::LabeledTuple<std::tuple<std::string, std::string, std::string>,
+                        utils::tstring::Service, utils::tstring::Path,
+                        utils::tstring::Metadata>;
diff --git a/src/types/trigger_types.hpp b/src/types/trigger_types.hpp
index b21e8eb..778a9a1 100644
--- a/src/types/trigger_types.hpp
+++ b/src/types/trigger_types.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "types/sensor_types.hpp"
 #include "utils/conversion.hpp"
 #include "utils/labeled_tuple.hpp"
 #include "utils/tstring.hpp"
@@ -31,6 +32,11 @@
     return utils::toEnum(details::convDataTriggerAction, str);
 }
 
+inline std::string actionToString(TriggerAction v)
+{
+    return std::string(utils::enumToString(details::convDataTriggerAction, v));
+}
+
 namespace discrete
 {
 
@@ -132,14 +138,6 @@
                         utils::tstring::ThresholdValue>;
 } // namespace numeric
 
-using SensorsInfo =
-    std::vector<std::pair<sdbusplus::message::object_path, std::string>>;
-
-using LabeledSensorInfo =
-    utils::LabeledTuple<std::tuple<std::string, std::string, std::string>,
-                        utils::tstring::Service, utils::tstring::SensorPath,
-                        utils::tstring::Metadata>;
-
 using TriggerThresholdParamsExt =
     std::variant<std::monostate, std::vector<numeric::ThresholdParam>,
                  std::vector<discrete::ThresholdParam>>;
@@ -152,6 +150,10 @@
     std::variant<std::vector<numeric::LabeledThresholdParam>,
                  std::vector<discrete::LabeledThresholdParam>>;
 
+using LabeledThresholdParam =
+    std::variant<std::monostate, numeric::LabeledThresholdParam,
+                 discrete::LabeledThresholdParam>;
+
 inline bool
     isTriggerThresholdDiscrete(const LabeledTriggerThresholdParams& params)
 {
diff --git a/src/utils/conversion_trigger.cpp b/src/utils/conversion_trigger.cpp
index ab06a48..e1b835a 100644
--- a/src/utils/conversion_trigger.cpp
+++ b/src/utils/conversion_trigger.cpp
@@ -1,6 +1,7 @@
 #include "utils/conversion_trigger.hpp"
 
 #include "utils/transform.hpp"
+#include "utils/tstring.hpp"
 
 #include <sdbusplus/exception.hpp>
 
@@ -72,11 +73,61 @@
 {
     return utils::transform(infos, [](const LabeledSensorInfo& val) {
         return SensorsInfo::value_type(
-            sdbusplus::message::object_path(val.at_label<ts::SensorPath>()),
+            sdbusplus::message::object_path(val.at_label<ts::Path>()),
             val.at_label<ts::Metadata>());
     });
 }
 
+TriggerThresholdParams
+    fromLabeledThresholdParam(const std::vector<LabeledThresholdParam>& params)
+{
+    namespace ts = utils::tstring;
+    if (isFirstElementOfType<std::monostate>(params))
+    {
+        return std::vector<discrete::ThresholdParam>();
+    }
+
+    if (isFirstElementOfType<discrete::LabeledThresholdParam>(params))
+    {
+        return utils::transform(params, [](const auto& param) {
+            const discrete::LabeledThresholdParam* paramUnpacked =
+                std::get_if<discrete::LabeledThresholdParam>(&param);
+            if (!paramUnpacked)
+            {
+                throw std::runtime_error(
+                    "Mixing threshold types is not allowed");
+            }
+            return discrete::ThresholdParam(
+                paramUnpacked->at_label<ts::UserId>(),
+                discrete::severityToString(
+                    paramUnpacked->at_label<ts::Severity>()),
+                paramUnpacked->at_label<ts::DwellTime>(),
+                paramUnpacked->at_label<ts::ThresholdValue>());
+        });
+    }
+
+    if (isFirstElementOfType<numeric::LabeledThresholdParam>(params))
+    {
+        return utils::transform(params, [](const auto& param) {
+            const numeric::LabeledThresholdParam* paramUnpacked =
+                std::get_if<numeric::LabeledThresholdParam>(&param);
+            if (!paramUnpacked)
+            {
+                throw std::runtime_error(
+                    "Mixing threshold types is not allowed");
+            }
+            return numeric::ThresholdParam(
+                numeric::typeToString(paramUnpacked->at_label<ts::Type>()),
+                paramUnpacked->at_label<ts::DwellTime>(),
+                numeric::directionToString(
+                    paramUnpacked->at_label<ts::Direction>()),
+                paramUnpacked->at_label<ts::ThresholdValue>());
+        });
+    }
+
+    throw std::runtime_error("Incorrect threshold params");
+}
+
 nlohmann::json labeledThresholdParamsToJson(
     const LabeledTriggerThresholdParams& labeledThresholdParams)
 {
diff --git a/src/utils/conversion_trigger.hpp b/src/utils/conversion_trigger.hpp
index 5229e5e..a749962 100644
--- a/src/utils/conversion_trigger.hpp
+++ b/src/utils/conversion_trigger.hpp
@@ -27,7 +27,32 @@
 
 SensorsInfo fromLabeledSensorsInfo(const std::vector<LabeledSensorInfo>& infos);
 
+TriggerThresholdParams
+    fromLabeledThresholdParam(const std::vector<LabeledThresholdParam>& params);
+
 nlohmann::json labeledThresholdParamsToJson(
     const LabeledTriggerThresholdParams& labeledThresholdParams);
 
+template <typename T>
+struct is_variant : std::false_type
+{};
+
+template <typename... Args>
+struct is_variant<std::variant<Args...>> : std::true_type
+{};
+
+template <typename T>
+inline constexpr bool is_variant_v = is_variant<T>::value;
+
+template <typename AlternativeT, typename VariantT>
+requires is_variant_v<VariantT>
+bool isFirstElementOfType(const std::vector<VariantT>& collection)
+{
+    if (collection.empty())
+    {
+        return false;
+    }
+    return std::holds_alternative<AlternativeT>(*collection.begin());
+}
+
 } // namespace utils
diff --git a/src/utils/dbus_mapper.hpp b/src/utils/dbus_mapper.hpp
index 78cf7b2..5f07445 100644
--- a/src/utils/dbus_mapper.hpp
+++ b/src/utils/dbus_mapper.hpp
@@ -17,19 +17,20 @@
 using SensorIfaces = std::vector<std::pair<ServiceName, Ifaces>>;
 using SensorTree = std::pair<SensorPath, SensorIfaces>;
 
+constexpr std::array<const char*, 1> sensorInterfaces = {
+    "xyz.openbmc_project.Sensor.Value"};
+
 inline std::vector<SensorTree>
     getSubTreeSensors(boost::asio::yield_context& yield,
                       const std::shared_ptr<sdbusplus::asio::connection>& bus)
 {
-    std::array<const char*, 1> interfaces = {
-        "xyz.openbmc_project.Sensor.Value"};
     boost::system::error_code ec;
 
     auto tree = bus->yield_method_call<std::vector<SensorTree>>(
         yield, ec, "xyz.openbmc_project.ObjectMapper",
         "/xyz/openbmc_project/object_mapper",
         "xyz.openbmc_project.ObjectMapper", "GetSubTree",
-        "/xyz/openbmc_project/sensors", 2, interfaces);
+        "/xyz/openbmc_project/sensors", 2, sensorInterfaces);
     if (ec)
     {
         throw std::runtime_error("Failed to query ObjectMapper!");
@@ -37,4 +38,20 @@
     return tree;
 }
 
+inline std::vector<SensorTree>
+    getSubTreeSensors(const std::shared_ptr<sdbusplus::asio::connection>& bus)
+{
+    auto method_call =
+        bus->new_method_call("xyz.openbmc_project.ObjectMapper",
+                             "/xyz/openbmc_project/object_mapper",
+                             "xyz.openbmc_project.ObjectMapper", "GetSubTree");
+    method_call.append("/xyz/openbmc_project/sensors/", 2, sensorInterfaces);
+    auto reply = bus->call(method_call);
+
+    std::vector<SensorTree> tree;
+    reply.read(tree);
+
+    return tree;
+}
+
 } // namespace utils
diff --git a/src/utils/threshold_operations.hpp b/src/utils/threshold_operations.hpp
new file mode 100644
index 0000000..04b0195
--- /dev/null
+++ b/src/utils/threshold_operations.hpp
@@ -0,0 +1,69 @@
+#pragma once
+
+#include "interfaces/sensor.hpp"
+
+#include <boost/asio/io_context.hpp>
+
+struct ThresholdOperations
+{
+    template <typename ThresholdType>
+    void initialize(ThresholdType* thresholdPtr)
+    {
+        for ([[maybe_unused]] auto& [sensor, detail] :
+             thresholdPtr->sensorDetails)
+        {
+            sensor->registerForUpdates(thresholdPtr->weak_from_this());
+        }
+        thresholdPtr->initialized = true;
+    }
+
+    template <typename ThresholdType>
+    typename ThresholdType::ThresholdDetail&
+        getDetails(ThresholdType* thresholdPtr,
+                   const interfaces::Sensor& sensor)
+    {
+        auto it = std::find_if(
+            thresholdPtr->sensorDetails.begin(),
+            thresholdPtr->sensorDetails.end(),
+            [&sensor](const auto& x) { return &sensor == x.first.get(); });
+        return *it->second;
+    }
+
+    template <typename ThresholdType>
+    void updateSensors(ThresholdType* thresholdPtr, Sensors newSensors)
+    {
+        typename ThresholdType::SensorDetails newSensorDetails;
+        typename ThresholdType::SensorDetails oldSensorDetails =
+            thresholdPtr->sensorDetails;
+
+        for (const auto& sensor : newSensors)
+        {
+            auto it = std::find_if(
+                oldSensorDetails.begin(), oldSensorDetails.end(),
+                [&sensor](const auto& sd) { return sensor == sd.first; });
+            if (it != oldSensorDetails.end())
+            {
+                newSensorDetails.emplace(*it);
+                oldSensorDetails.erase(it);
+                continue;
+            }
+
+            newSensorDetails.emplace(
+                sensor, thresholdPtr->makeDetails(sensor->getName()));
+            if (thresholdPtr->initialized)
+            {
+                sensor->registerForUpdates(thresholdPtr->weak_from_this());
+            }
+        }
+
+        if (thresholdPtr->initialized)
+        {
+            for ([[maybe_unused]] auto& [sensor, detail] : oldSensorDetails)
+            {
+                sensor->unregisterFromUpdates(thresholdPtr->weak_from_this());
+            }
+        }
+
+        thresholdPtr->sensorDetails = std::move(newSensorDetails);
+    }
+};
diff --git a/tests/src/mocks/report_factory_mock.hpp b/tests/src/mocks/report_factory_mock.hpp
index 58c71d6..c2e4dd2 100644
--- a/tests/src/mocks/report_factory_mock.hpp
+++ b/tests/src/mocks/report_factory_mock.hpp
@@ -16,7 +16,7 @@
             return LabeledMetricParameters(
                 utils::transform(std::get<0>(params),
                                  [](const auto& sensorData) {
-                                     return LabeledSensorParameters(
+                                     return LabeledSensorInfo(
                                          "Service", std::get<0>(sensorData),
                                          std::get<1>(sensorData));
                                  }),
diff --git a/tests/src/mocks/sensor_mock.hpp b/tests/src/mocks/sensor_mock.hpp
index 9ff72e2..9b7f28b 100644
--- a/tests/src/mocks/sensor_mock.hpp
+++ b/tests/src/mocks/sensor_mock.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "interfaces/sensor.hpp"
+#include "utils/conv_container.hpp"
 #include "utils/generate_unique_mock_id.hpp"
 
 #include <gmock/gmock.h>
@@ -23,12 +24,30 @@
         return Id("SensorMock", service, path);
     }
 
+    static std::vector<std::shared_ptr<interfaces::Sensor>>
+        makeSensorMocks(const std::vector<LabeledSensorInfo>& sensorsInfo)
+    {
+        using namespace testing;
+        std::vector<std::shared_ptr<NiceMock<SensorMock>>> result;
+        for (const auto& sensorInfo : sensorsInfo)
+        {
+            auto& sensorMock =
+                result.emplace_back(std::make_shared<NiceMock<SensorMock>>());
+            ON_CALL(*sensorMock, getLabeledSensorInfo())
+                .WillByDefault(Return(sensorInfo));
+        }
+        return utils::convContainer<std::shared_ptr<interfaces::Sensor>>(
+            result);
+    }
+
     MOCK_METHOD(Id, id, (), (const, override));
     MOCK_METHOD(std::string, metadata, (), (const, override));
+    MOCK_METHOD(std::string, getName, (), (const, override));
     MOCK_METHOD(void, registerForUpdates,
                 (const std::weak_ptr<interfaces::SensorListener>&), (override));
     MOCK_METHOD(void, unregisterFromUpdates,
                 (const std::weak_ptr<interfaces::SensorListener>&), (override));
+    MOCK_METHOD(LabeledSensorInfo, getLabeledSensorInfo, (), (const, override));
 
     const uint64_t mockId = generateUniqueMockId();
 
diff --git a/tests/src/mocks/threshold_mock.hpp b/tests/src/mocks/threshold_mock.hpp
new file mode 100644
index 0000000..2f81b60
--- /dev/null
+++ b/tests/src/mocks/threshold_mock.hpp
@@ -0,0 +1,64 @@
+#pragma once
+
+#include "interfaces/sensor.hpp"
+#include "interfaces/threshold.hpp"
+#include "utils/conv_container.hpp"
+
+#include <vector>
+
+#include <gmock/gmock.h>
+
+class ThresholdMock :
+    public interfaces::Threshold,
+    public std::enable_shared_from_this<ThresholdMock>
+{
+  public:
+    MOCK_METHOD(void, initialize, (), (override));
+
+    MOCK_METHOD(LabeledThresholdParam, getThresholdParam, (),
+                (const, override));
+
+    MOCK_METHOD(void, updateSensors, (Sensors newSensors), (override));
+
+    static std::vector<std::shared_ptr<interfaces::Threshold>>
+        makeThresholds(const LabeledTriggerThresholdParams& params)
+    {
+        using namespace testing;
+        std::vector<std::shared_ptr<NiceMock<ThresholdMock>>> result;
+        if (std::holds_alternative<std::vector<numeric::LabeledThresholdParam>>(
+                params))
+        {
+            auto unpackedParams =
+                std::get<std::vector<numeric::LabeledThresholdParam>>(params);
+            for (const auto& param : unpackedParams)
+            {
+                auto& thresholdMock = result.emplace_back(
+                    std::make_shared<NiceMock<ThresholdMock>>());
+                ON_CALL(*thresholdMock, getThresholdParam())
+                    .WillByDefault(Return(param));
+            }
+        }
+        else
+        {
+            auto unpackedParams =
+                std::get<std::vector<discrete::LabeledThresholdParam>>(params);
+            for (const auto& param : unpackedParams)
+            {
+                auto& thresholdMock = result.emplace_back(
+                    std::make_shared<NiceMock<ThresholdMock>>());
+                ON_CALL(*thresholdMock, getThresholdParam())
+                    .WillByDefault(Return(param));
+            }
+            if (unpackedParams.empty())
+            {
+                auto& thresholdMock = result.emplace_back(
+                    std::make_shared<NiceMock<ThresholdMock>>());
+                ON_CALL(*thresholdMock, getThresholdParam())
+                    .WillByDefault(Return(std::monostate{}));
+            }
+        }
+
+        return utils::convContainer<std::shared_ptr<interfaces::Threshold>>(
+            result);
+    }
+};
diff --git a/tests/src/mocks/trigger_factory_mock.hpp b/tests/src/mocks/trigger_factory_mock.hpp
index 9fa2f48..80a62a1 100644
--- a/tests/src/mocks/trigger_factory_mock.hpp
+++ b/tests/src/mocks/trigger_factory_mock.hpp
@@ -5,6 +5,7 @@
 #include "params/trigger_params.hpp"
 #include "trigger.hpp"
 #include "utils/conversion_trigger.hpp"
+#include "utils/transform.hpp"
 
 #include <gmock/gmock.h>
 
@@ -35,6 +36,23 @@
                 (boost::asio::yield_context&, const SensorsInfo&),
                 (const, override));
 
+    MOCK_METHOD(std::vector<LabeledSensorInfo>, getLabeledSensorsInfo,
+                (const SensorsInfo&), (const, override));
+
+    MOCK_METHOD(void, updateThresholds,
+                (std::vector<std::shared_ptr<interfaces::Threshold>> &
+                     currentThresholds,
+                 const std::vector<TriggerAction>& triggerActions,
+                 const std::shared_ptr<std::vector<std::string>>& reportIds,
+                 const Sensors& sensors,
+                 const LabeledTriggerThresholdParams& newParams),
+                (const, override));
+
+    MOCK_METHOD(void, updateSensors,
+                (Sensors & currentSensors,
+                 const std::vector<LabeledSensorInfo>& senorParams),
+                (const, override));
+
     auto& expectMake(
         std::optional<TriggerParams> paramsOpt,
         const testing::Matcher<interfaces::TriggerManager&>& tm,
@@ -53,7 +71,11 @@
                 .WillByDefault(Return(params.sensors()));
 
             return EXPECT_CALL(
-                *this, make(params.id(), params.name(), params.triggerActions(),
+                *this, make(params.id(), params.name(),
+                            utils::transform(params.triggerActions(),
+                                             [](const auto& action) {
+                                                 return actionToString(action);
+                                             }),
                             params.reportIds(), tm, triggerStorage,
                             params.thresholdParams(), params.sensors()));
         }
diff --git a/tests/src/params/report_params.hpp b/tests/src/params/report_params.hpp
index 47e74e3..19ea519 100644
--- a/tests/src/params/report_params.hpp
+++ b/tests/src/params/report_params.hpp
@@ -118,17 +118,17 @@
     ReportUpdates reportUpdatesProperty = ReportUpdates::overwrite;
     std::vector<LabeledMetricParameters> metricParametersProperty{
         {LabeledMetricParameters{
-             {LabeledSensorParameters{"Service",
-                                      "/xyz/openbmc_project/sensors/power/p1",
-                                      "metadata1"}},
+             {LabeledSensorInfo{"Service",
+                                "/xyz/openbmc_project/sensors/power/p1",
+                                "metadata1"}},
              OperationType::single,
              "MetricId1",
              CollectionTimeScope::point,
              CollectionDuration(Milliseconds(0u))},
          LabeledMetricParameters{
-             {LabeledSensorParameters{"Service",
-                                      "/xyz/openbmc_project/sensors/power/p2",
-                                      "metadata2"}},
+             {LabeledSensorInfo{"Service",
+                                "/xyz/openbmc_project/sensors/power/p2",
+                                "metadata2"}},
              OperationType::single,
              "MetricId2",
              CollectionTimeScope::point,
diff --git a/tests/src/params/trigger_params.hpp b/tests/src/params/trigger_params.hpp
index 886cf78..ea7f7dc 100644
--- a/tests/src/params/trigger_params.hpp
+++ b/tests/src/params/trigger_params.hpp
@@ -33,13 +33,13 @@
         return nameProperty;
     }
 
-    TriggerParams& triggerActions(const std::vector<std::string>& val)
+    TriggerParams& triggerActions(const std::vector<TriggerAction>& val)
     {
         triggerActionsProperty = val;
         return *this;
     }
 
-    const std::vector<std::string>& triggerActions() const
+    const std::vector<TriggerAction>& triggerActions() const
     {
         return triggerActionsProperty;
     }
@@ -68,8 +68,8 @@
   private:
     std::string idProperty = "Trigger1";
     std::string nameProperty = "My Numeric Trigger";
-    std::vector<std::string> triggerActionsProperty = {"UpdateReport"};
-
+    std::vector<TriggerAction> triggerActionsProperty = {
+        TriggerAction::UpdateReport};
     std::vector<LabeledSensorInfo> labeledSensorsProperty = {
         {"service1", "/xyz/openbmc_project/sensors/temperature/BMC_Temp",
          "metadata1"}};
diff --git a/tests/src/test_discrete_threshold.cpp b/tests/src/test_discrete_threshold.cpp
index 3dd2baa..ebd50cc 100644
--- a/tests/src/test_discrete_threshold.cpp
+++ b/tests/src/test_discrete_threshold.cpp
@@ -23,8 +23,9 @@
     TriggerActionMock& actionMock = *actionMockPtr;
     std::shared_ptr<DiscreteThreshold> sut;
 
-    std::shared_ptr<DiscreteThreshold> makeThreshold(Milliseconds dwellTime,
-                                                     double thresholdValue)
+    std::shared_ptr<DiscreteThreshold>
+        makeThreshold(Milliseconds dwellTime, double thresholdValue,
+                      discrete::Severity severity = discrete::Severity::ok)
     {
         std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
         actions.push_back(std::move(actionMockPtr));
@@ -33,13 +34,19 @@
             DbusEnvironment::getIoc(),
             utils::convContainer<std::shared_ptr<interfaces::Sensor>>(
                 sensorMocks),
-            sensorNames, std::move(actions), dwellTime, thresholdValue,
-            "treshold_name");
+            std::move(actions), dwellTime, thresholdValue, "treshold name",
+            severity);
     }
 
     void SetUp() override
     {
-        sut = makeThreshold(0ms, 90.0);
+        for (size_t idx = 0; idx < sensorMocks.size(); idx++)
+        {
+            ON_CALL(*sensorMocks.at(idx), getName())
+                .WillByDefault(Return(sensorNames[idx]));
+        }
+
+        sut = makeThreshold(0ms, 90.0, discrete::Severity::critical);
     }
 };
 
@@ -61,6 +68,13 @@
     EXPECT_CALL(actionMock, commit(_, _, _)).Times(0);
 }
 
+TEST_F(TestDiscreteThreshold, getLabeledParamsReturnsCorrectly)
+{
+    LabeledThresholdParam expected = discrete::LabeledThresholdParam(
+        "treshold name", discrete::Severity::critical, 0, std::to_string(90.0));
+    EXPECT_EQ(sut->getThresholdParam(), expected);
+}
+
 struct DiscreteParams
 {
     struct UpdateParams
@@ -200,6 +214,13 @@
   public:
     void SetUp() override
     {
+
+        for (size_t idx = 0; idx < sensorMocks.size(); idx++)
+        {
+            ON_CALL(*sensorMocks.at(idx), getName())
+                .WillByDefault(Return(sensorNames[idx]));
+        }
+
         sut = makeThreshold(0ms, GetParam().thresholdValue);
     }
 };
@@ -235,6 +256,12 @@
   public:
     void SetUp() override
     {
+        for (size_t idx = 0; idx < sensorMocks.size(); idx++)
+        {
+            ON_CALL(*sensorMocks.at(idx), getName())
+                .WillByDefault(Return(sensorNames[idx]));
+        }
+
         sut = makeThreshold(GetParam().dwellTime, GetParam().thresholdValue);
     }
 };
diff --git a/tests/src/test_metric.cpp b/tests/src/test_metric.cpp
index bd1d8c4..fcb2ded 100644
--- a/tests/src/test_metric.cpp
+++ b/tests/src/test_metric.cpp
@@ -145,7 +145,7 @@
     expected.at_label<ts::CollectionTimeScope>() = params.collectionTimeScope();
     expected.at_label<ts::CollectionDuration>() = params.collectionDuration();
     expected.at_label<ts::SensorPath>() = {
-        LabeledSensorParameters("service1", "path1", "metadata1")};
+        LabeledSensorInfo("service1", "path1", "metadata1")};
 
     EXPECT_THAT(conf, Eq(expected));
 }
diff --git a/tests/src/test_numeric_threshold.cpp b/tests/src/test_numeric_threshold.cpp
index 851d4a9..65c976c 100644
--- a/tests/src/test_numeric_threshold.cpp
+++ b/tests/src/test_numeric_threshold.cpp
@@ -23,7 +23,8 @@
     std::shared_ptr<NumericThreshold> sut;
 
     void makeThreshold(Milliseconds dwellTime, numeric::Direction direction,
-                       double thresholdValue)
+                       double thresholdValue,
+                       numeric::Type type = numeric::Type::lowerWarning)
     {
         std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
         actions.push_back(std::move(actionMockPtr));
@@ -32,13 +33,19 @@
             DbusEnvironment::getIoc(),
             utils::convContainer<std::shared_ptr<interfaces::Sensor>>(
                 sensorMocks),
-            sensorNames, std::move(actions), dwellTime, direction,
-            thresholdValue);
+            std::move(actions), dwellTime, direction, thresholdValue, type);
     }
 
     void SetUp() override
     {
-        makeThreshold(0ms, numeric::Direction::increasing, 90.0);
+        for (size_t idx = 0; idx < sensorMocks.size(); idx++)
+        {
+            ON_CALL(*sensorMocks.at(idx), getName())
+                .WillByDefault(Return(sensorNames[idx]));
+        }
+
+        makeThreshold(0ms, numeric::Direction::increasing, 90.0,
+                      numeric::Type::upperCritical);
     }
 };
 
@@ -60,6 +67,13 @@
     EXPECT_CALL(actionMock, commit(_, _, _)).Times(0);
 }
 
+TEST_F(TestNumericThreshold, getLabeledParamsReturnsCorrectly)
+{
+    LabeledThresholdParam expected = numeric::LabeledThresholdParam(
+        numeric::Type::upperCritical, 0, numeric::Direction::increasing, 90.0);
+    EXPECT_EQ(sut->getThresholdParam(), expected);
+}
+
 struct NumericParams
 {
     NumericParams& Direction(numeric::Direction val)
@@ -114,6 +128,12 @@
   public:
     void SetUp() override
     {
+        for (size_t idx = 0; idx < sensorMocks.size(); idx++)
+        {
+            ON_CALL(*sensorMocks.at(idx), getName())
+                .WillByDefault(Return(sensorNames[idx]));
+        }
+
         makeThreshold(0ms, GetParam().direction, 90.0);
     }
 };
@@ -205,6 +225,12 @@
   public:
     void SetUp() override
     {
+        for (size_t idx = 0; idx < sensorMocks.size(); idx++)
+        {
+            ON_CALL(*sensorMocks.at(idx), getName())
+                .WillByDefault(Return(sensorNames[idx]));
+        }
+
         makeThreshold(2ms, GetParam().direction, 90.0);
     }
 
@@ -303,6 +329,12 @@
   public:
     void SetUp() override
     {
+        for (size_t idx = 0; idx < sensorMocks.size(); idx++)
+        {
+            ON_CALL(*sensorMocks.at(idx), getName())
+                .WillByDefault(Return(sensorNames[idx]));
+        }
+
         makeThreshold(2ms, GetParam().direction, 90.0);
     }
 
diff --git a/tests/src/test_on_change_threshold.cpp b/tests/src/test_on_change_threshold.cpp
index 75a63c5..0c3b301 100644
--- a/tests/src/test_on_change_threshold.cpp
+++ b/tests/src/test_on_change_threshold.cpp
@@ -27,10 +27,16 @@
         std::vector<std::unique_ptr<interfaces::TriggerAction>> actions;
         actions.push_back(std::move(actionMockPtr));
 
+        for (size_t idx = 0; idx < sensorMocks.size(); idx++)
+        {
+            ON_CALL(*sensorMocks.at(idx), getName())
+                .WillByDefault(Return(sensorNames[idx]));
+        }
+
         sut = std::make_shared<OnChangeThreshold>(
             utils::convContainer<std::shared_ptr<interfaces::Sensor>>(
                 sensorMocks),
-            sensorNames, std::move(actions));
+            std::move(actions));
     }
 };
 
@@ -52,6 +58,12 @@
     EXPECT_CALL(actionMock, commit(_, _, _)).Times(0);
 }
 
+TEST_F(TestOnChangeThreshold, getLabeledParamsReturnsCorrectly)
+{
+    LabeledThresholdParam expected = std::monostate();
+    EXPECT_EQ(sut->getThresholdParam(), expected);
+}
+
 struct OnChangeParams
 {
     using UpdateParams = std::tuple<size_t, Milliseconds, double>;
diff --git a/tests/src/test_report_manager.cpp b/tests/src/test_report_manager.cpp
index a18579c..10b4de9 100644
--- a/tests/src/test_report_manager.cpp
+++ b/tests/src/test_report_manager.cpp
@@ -215,9 +215,9 @@
 
     reportParams.metricParameters(
         std::vector<LabeledMetricParameters>{{LabeledMetricParameters{
-            {LabeledSensorParameters{"Service",
-                                     "/xyz/openbmc_project/sensors/power/p1",
-                                     "Metadata1"}},
+            {LabeledSensorInfo{"Service",
+                               "/xyz/openbmc_project/sensors/power/p1",
+                               "Metadata1"}},
             OperationType::single,
             "MetricId1",
             CollectionTimeScope::point,
@@ -229,7 +229,7 @@
 
     for (size_t i = 0; i < ReportManager::maxNumberMetrics; i++)
     {
-        metricParamsVec.emplace_back(LabeledSensorParameters{
+        metricParamsVec.emplace_back(LabeledSensorInfo{
             "Service", "/xyz/openbmc_project/sensors/power/p1", "Metadata1"});
     }
 
@@ -396,9 +396,9 @@
 {
     reportParams.metricParameters(
         std::vector<LabeledMetricParameters>{{LabeledMetricParameters{
-            {LabeledSensorParameters{"Service",
-                                     "/xyz/openbmc_project/sensors/power/p1",
-                                     "Metadata1"}},
+            {LabeledSensorInfo{"Service",
+                               "/xyz/openbmc_project/sensors/power/p1",
+                               "Metadata1"}},
             operationType,
             "MetricId1",
             CollectionTimeScope::point,
diff --git a/tests/src/test_sensor.cpp b/tests/src/test_sensor.cpp
index c0a9dc3..c073ee7 100644
--- a/tests/src/test_sensor.cpp
+++ b/tests/src/test_sensor.cpp
@@ -97,6 +97,31 @@
     ASSERT_TRUE(DbusEnvironment::waitForFuture("async_read2"));
 }
 
+TEST_F(TestSensor, getLabeledInfoReturnsCorrectly)
+{
+    auto expected = LabeledSensorInfo(DbusEnvironment::serviceName(),
+                                      sensorObject->path(), "metadata");
+    EXPECT_EQ(sut->getLabeledSensorInfo(), expected);
+}
+
+TEST_F(TestSensor, getNameReturnsPathWhenMetadataIsNotSet)
+{
+    static const char* path = "/telemetry/ut/DbusSensorObject2";
+    sut = sensorCache.makeSensor<Sensor>(DbusEnvironment::serviceName(), path,
+                                         "", DbusEnvironment::getIoc(),
+                                         DbusEnvironment::getBus());
+    EXPECT_EQ(sut->getName(), path);
+}
+
+TEST_F(TestSensor, getNameReturnsMetadataWhenMetadataIsSet)
+{
+    static const char* path = "/telemetry/ut/DbusSensorObject2";
+    sut = sensorCache.makeSensor<Sensor>(DbusEnvironment::serviceName(), path,
+                                         "metadata2", DbusEnvironment::getIoc(),
+                                         DbusEnvironment::getBus());
+    EXPECT_EQ(sut->getName(), "metadata2");
+}
+
 class TestSensorNotification : public TestSensor
 {
   public:
diff --git a/tests/src/test_trigger.cpp b/tests/src/test_trigger.cpp
index 66e9bf0..a2286ee 100644
--- a/tests/src/test_trigger.cpp
+++ b/tests/src/test_trigger.cpp
@@ -1,6 +1,9 @@
 #include "dbus_environment.hpp"
 #include "helpers.hpp"
 #include "mocks/json_storage_mock.hpp"
+#include "mocks/sensor_mock.hpp"
+#include "mocks/threshold_mock.hpp"
+#include "mocks/trigger_factory_mock.hpp"
 #include "mocks/trigger_manager_mock.hpp"
 #include "params/trigger_params.hpp"
 #include "trigger.hpp"
@@ -14,7 +17,7 @@
 using namespace testing;
 using namespace std::literals::string_literals;
 
-static constexpr size_t expectedTriggerVersion = 0;
+static constexpr size_t expectedTriggerVersion = 1;
 
 class TestTrigger : public Test
 {
@@ -35,7 +38,10 @@
 
     std::unique_ptr<TriggerManagerMock> triggerManagerMockPtr =
         std::make_unique<NiceMock<TriggerManagerMock>>();
+    std::unique_ptr<TriggerFactoryMock> triggerFactoryMockPtr =
+        std::make_unique<NiceMock<TriggerFactoryMock>>();
     testing::NiceMock<StorageMock> storageMock;
+    std::vector<std::shared_ptr<interfaces::Threshold>> thresholdMocks;
     std::unique_ptr<Trigger> sut;
 
     void SetUp() override
@@ -54,12 +60,17 @@
 
     std::unique_ptr<Trigger> makeTrigger(const TriggerParams& params)
     {
+        thresholdMocks =
+            ThresholdMock::makeThresholds(params.thresholdParams());
+
         return std::make_unique<Trigger>(
             DbusEnvironment::getIoc(), DbusEnvironment::getObjServer(),
             params.id(), params.name(), params.triggerActions(),
-            params.reportIds(), params.sensors(), params.thresholdParams(),
-            std::vector<std::shared_ptr<interfaces::Threshold>>{},
-            *triggerManagerMockPtr, storageMock);
+            std::make_shared<std::vector<std::string>>(
+                params.reportIds().begin(), params.reportIds().end()),
+            std::vector<std::shared_ptr<interfaces::Threshold>>(thresholdMocks),
+            *triggerManagerMockPtr, storageMock, *triggerFactoryMockPtr,
+            SensorMock::makeSensorMocks(params.sensors()));
     }
 
     static interfaces::JsonStorage::FilePath to_file_path(std::string name)
@@ -104,13 +115,18 @@
     EXPECT_THAT(getProperty<bool>(sut->getPath(), "Persistent"), Eq(true));
     EXPECT_THAT(
         getProperty<std::vector<std::string>>(sut->getPath(), "TriggerActions"),
-        Eq(triggerParams.triggerActions()));
+        Eq(utils::transform(
+            triggerParams.triggerActions(),
+            [](const auto& action) { return actionToString(action); })));
     EXPECT_THAT((getProperty<SensorsInfo>(sut->getPath(), "Sensors")),
                 Eq(utils::fromLabeledSensorsInfo(triggerParams.sensors())));
     EXPECT_THAT(
         getProperty<std::vector<std::string>>(sut->getPath(), "ReportNames"),
         Eq(triggerParams.reportIds()));
     EXPECT_THAT(
+        getProperty<bool>(sut->getPath(), "Discrete"),
+        Eq(isTriggerThresholdDiscrete(triggerParams.thresholdParams())));
+    EXPECT_THAT(
         getProperty<TriggerThresholdParams>(sut->getPath(), "Thresholds"),
         Eq(std::visit(utils::FromLabeledThresholdParamConversion(),
                       triggerParams.thresholdParams())));
@@ -124,6 +140,41 @@
     EXPECT_THAT(getProperty<std::string>(sut->getPath(), "Name"), Eq(name));
 }
 
+TEST_F(TestTrigger, setPropertyReportNames)
+{
+    std::vector<std::string> newNames = {"abc", "one", "two"};
+    EXPECT_THAT(setProperty(sut->getPath(), "ReportNames", newNames),
+                Eq(boost::system::errc::success));
+    EXPECT_THAT(
+        getProperty<std::vector<std::string>>(sut->getPath(), "ReportNames"),
+        Eq(newNames));
+}
+
+TEST_F(TestTrigger, setPropertySensors)
+{
+    EXPECT_CALL(*triggerFactoryMockPtr, updateSensors(_, _));
+    for (const auto& threshold : thresholdMocks)
+    {
+        auto thresholdMockPtr =
+            std::dynamic_pointer_cast<NiceMock<ThresholdMock>>(threshold);
+        EXPECT_CALL(*thresholdMockPtr, updateSensors(_));
+    }
+    SensorsInfo newSensors({std::make_pair(
+        sdbusplus::message::object_path("/abc/def"), "metadata")});
+    EXPECT_THAT(setProperty(sut->getPath(), "Sensors", newSensors),
+                Eq(boost::system::errc::success));
+}
+
+TEST_F(TestTrigger, setPropertyThresholds)
+{
+    EXPECT_CALL(*triggerFactoryMockPtr, updateThresholds(_, _, _, _, _));
+    TriggerThresholdParams newThresholds =
+        std::vector<discrete::ThresholdParam>(
+            {std::make_tuple("discrete threshold", "OK", 10, "12.3")});
+    EXPECT_THAT(setProperty(sut->getPath(), "Thresholds", newThresholds),
+                Eq(boost::system::errc::success));
+}
+
 TEST_F(TestTrigger, checkIfNumericCoversionsAreGood)
 {
     const auto& labeledParamsBase =
@@ -265,7 +316,10 @@
 TEST_F(TestTriggerStore, settingPersistencyToTrueStoresTriggerTriggerActions)
 {
     ASSERT_THAT(storedConfiguration.at("TriggerActions"),
-                Eq(triggerParams.triggerActions()));
+                Eq(utils::transform(triggerParams.triggerActions(),
+                                    [](const auto& action) {
+                                        return actionToString(action);
+                                    })));
 }
 
 TEST_F(TestTriggerStore, settingPersistencyToTrueStoresTriggerReportIds)
@@ -278,8 +332,7 @@
 {
     nlohmann::json expectedItem;
     expectedItem["service"] = "service1";
-    expectedItem["sensorPath"] =
-        "/xyz/openbmc_project/sensors/temperature/BMC_Temp";
+    expectedItem["path"] = "/xyz/openbmc_project/sensors/temperature/BMC_Temp";
     expectedItem["metadata"] = "metadata1";
 
     ASSERT_THAT(storedConfiguration.at("Sensors"), ElementsAre(expectedItem));
diff --git a/tests/src/test_trigger_actions.cpp b/tests/src/test_trigger_actions.cpp
index 1c36326..b902e5a 100644
--- a/tests/src/test_trigger_actions.cpp
+++ b/tests/src/test_trigger_actions.cpp
@@ -220,7 +220,9 @@
   public:
     void make(std::vector<std::string> names)
     {
-        sut = std::make_unique<UpdateReport>(reportManager, std::move(names));
+        sut = std::make_unique<UpdateReport>(
+            reportManager,
+            std::make_shared<std::vector<std::string>>(std::move(names)));
     }
 
     NiceMock<ReportManagerMock> reportManager;
diff --git a/tests/src/test_trigger_manager.cpp b/tests/src/test_trigger_manager.cpp
index 182c58b..ea4f0b9 100644
--- a/tests/src/test_trigger_manager.cpp
+++ b/tests/src/test_trigger_manager.cpp
@@ -29,8 +29,11 @@
             },
             DbusEnvironment::serviceName(), TriggerManager::triggerManagerPath,
             TriggerManager::triggerManagerIfaceName, "AddTrigger", params.id(),
-            params.name(), params.triggerActions(), sensorInfos,
-            params.reportIds(),
+            params.name(),
+            utils::transform(
+                params.triggerActions(),
+                [](const auto& action) { return actionToString(action); }),
+            sensorInfos, params.reportIds(),
             std::visit(utils::FromLabeledThresholdParamConversion(),
                        params.thresholdParams()));
         return DbusEnvironment::waitForFuture(addTriggerPromise.get_future());
@@ -291,7 +294,10 @@
         {"Name", TriggerParams().name()},
         {"ThresholdParamsDiscriminator",
          TriggerParams().thresholdParams().index()},
-        {"TriggerActions", TriggerParams().triggerActions()},
+        {"TriggerActions", utils::transform(TriggerParams().triggerActions(),
+                                            [](const auto& action) {
+                                                return actionToString(action);
+                                            })},
         {"ThresholdParams", utils::labeledThresholdParamsToJson(
                                 TriggerParams().thresholdParams())},
         {"ReportIds", TriggerParams().reportIds()},