diff --git a/libpldmresponder/event_parser.cpp b/libpldmresponder/event_parser.cpp
new file mode 100644
index 0000000..0a0000c
--- /dev/null
+++ b/libpldmresponder/event_parser.cpp
@@ -0,0 +1,162 @@
+#include "event_parser.hpp"
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <set>
+#include <xyz/openbmc_project/Common/error.hpp>
+
+namespace pldm::responder::events
+{
+
+namespace fs = std::filesystem;
+using InternalFailure =
+    sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
+
+const Json emptyJson{};
+const std::vector<Json> emptyJsonList{};
+const std::vector<std::string> emptyStringVec{};
+
+constexpr auto eventStateSensorJson = "event_state_sensor.json";
+
+const std::set<std::string_view> supportedDbusPropertyTypes = {
+    "bool",     "uint8_t", "int16_t",  "uint16_t", "int32_t",
+    "uint32_t", "int64_t", "uint64_t", "double",   "string"};
+
+StateSensorHandler::StateSensorHandler(const std::string& dirPath)
+{
+    fs::path dir(dirPath);
+    if (!fs::exists(dir) || fs::is_empty(dir))
+    {
+        std::cerr << "Event config directory does not exist or empty, DIR="
+                  << dirPath << "\n";
+        return;
+    }
+
+    fs::path filePath = dir / eventStateSensorJson;
+    if (!fs::exists(filePath))
+    {
+        std::cerr << "Event state sensor JSON does not exist, PATH=" << filePath
+                  << "\n";
+        throw InternalFailure();
+    }
+
+    std::ifstream jsonFile(filePath);
+
+    auto data = Json::parse(jsonFile, nullptr, false);
+    if (data.is_discarded())
+    {
+        std::cerr << "Parsing Event state sensor JSON file failed, FILE="
+                  << filePath;
+        throw InternalFailure();
+    }
+
+    auto entries = data.value("entries", emptyJsonList);
+    for (const auto& entry : entries)
+    {
+        StateSensorEntry stateSensorEntry{};
+        stateSensorEntry.containerId =
+            static_cast<uint16_t>(entry.value("containerID", 0));
+        stateSensorEntry.entityType =
+            static_cast<uint16_t>(entry.value("entityType", 0));
+        stateSensorEntry.entityInstance =
+            static_cast<uint16_t>(entry.value("entityInstance", 0));
+        stateSensorEntry.sensorOffset =
+            static_cast<uint8_t>(entry.value("sensorOffset", 0));
+
+        pldm::utils::DBusMapping dbusInfo{};
+
+        auto dbus = entry.value("dbus", emptyJson);
+        dbusInfo.objectPath = dbus.value("object_path", "");
+        dbusInfo.interface = dbus.value("interface", "");
+        dbusInfo.propertyName = dbus.value("property_name", "");
+        dbusInfo.propertyType = dbus.value("property_type", "");
+        if (dbusInfo.objectPath.empty() || dbusInfo.interface.empty() ||
+            dbusInfo.propertyName.empty() ||
+            (supportedDbusPropertyTypes.find(dbusInfo.propertyType) ==
+             supportedDbusPropertyTypes.end()))
+        {
+            std::cerr << "Invalid dbus config,"
+                      << " OBJPATH=" << dbusInfo.objectPath << " INTERFACE="
+                      << dbusInfo.interface << " PROPERTY_NAME="
+                      << dbusInfo.propertyName
+                      << " PROPERTY_TYPE=" << dbusInfo.propertyType << "\n";
+            continue;
+        }
+
+        auto eventStates = entry.value("event_states", emptyJsonList);
+        auto propertyValues = dbus.value("property_values", emptyJsonList);
+        if ((eventStates.size() == 0) || (propertyValues.size() == 0) ||
+            (eventStates.size() != propertyValues.size()))
+        {
+            std::cerr << "Invalid event state JSON config,"
+                      << " EVENT_STATE_SIZE=" << eventStates.size()
+                      << " PROPERTY_VALUE_SIZE=" << propertyValues.size()
+                      << "\n";
+            continue;
+        }
+
+        auto eventStateMap = mapStateToDBusVal(eventStates, propertyValues,
+                                               dbusInfo.propertyType);
+        eventMap.emplace(
+            stateSensorEntry,
+            std::make_tuple(std::move(dbusInfo), std::move(eventStateMap)));
+    }
+}
+
+StateToDBusValue StateSensorHandler::mapStateToDBusVal(
+    const Json& eventStates, const Json& propertyValues, std::string_view type)
+{
+    StateToDBusValue eventStateMap{};
+    auto stateIt = eventStates.begin();
+    auto propIt = propertyValues.begin();
+
+    for (; stateIt != eventStates.end(); ++stateIt, ++propIt)
+    {
+        auto propValue = utils::jsonEntryToDbusVal(type, propIt.value());
+        eventStateMap.emplace((*stateIt).get<uint8_t>(), std::move(propValue));
+    }
+
+    return eventStateMap;
+}
+
+int StateSensorHandler::eventAction(const StateSensorEntry& entry,
+                                    pdr::EventState state)
+{
+    try
+    {
+        const auto& [dbusMapping, eventStateMap] = eventMap.at(entry);
+        utils::PropertyValue propValue{};
+        try
+        {
+            propValue = eventStateMap.at(state);
+        }
+        catch (const std::out_of_range& e)
+        {
+            std::cerr << "Invalid event state" << static_cast<unsigned>(state)
+                      << '\n';
+            return PLDM_ERROR_INVALID_DATA;
+        }
+
+        try
+        {
+            pldm::utils::DBusHandler().setDbusProperty(dbusMapping, propValue);
+        }
+        catch (const std::exception& e)
+        {
+            std::cerr << "Error setting property, ERROR=" << e.what()
+                      << " PROPERTY=" << dbusMapping.propertyName
+                      << " INTERFACE=" << dbusMapping.interface << " PATH="
+                      << dbusMapping.objectPath << "\n";
+            return PLDM_ERROR;
+        }
+    }
+    catch (const std::out_of_range& e)
+    {
+        // There is no BMC action for this PLDM event
+        return PLDM_SUCCESS;
+    }
+    return PLDM_SUCCESS;
+}
+
+} // namespace pldm::responder::events
\ No newline at end of file
diff --git a/libpldmresponder/event_parser.hpp b/libpldmresponder/event_parser.hpp
new file mode 100644
index 0000000..1139c71
--- /dev/null
+++ b/libpldmresponder/event_parser.hpp
@@ -0,0 +1,120 @@
+#pragma once
+
+#include "types.hpp"
+#include "utils.hpp"
+
+#include <filesystem>
+#include <map>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace pldm::responder::events
+{
+
+/** @struct StateSensorEntry
+ *
+ *  StateSensorEntry is a key to uniquely identify a state sensor, so that a
+ *  D-Bus action can be defined for PlatformEventMessage command with
+ *  sensorEvent type. This struct is used as a key in a std::map so implemented
+ *  operator== and operator<.
+ */
+struct StateSensorEntry
+{
+    pdr::ContainerID containerId;
+    pdr::EntityType entityType;
+    pdr::EntityInstance entityInstance;
+    pdr::SensorOffset sensorOffset;
+
+    bool operator==(const StateSensorEntry& e) const
+    {
+        return ((containerId == e.containerId) &&
+                (entityType == e.entityType) &&
+                (entityInstance == e.entityInstance) &&
+                (sensorOffset == e.sensorOffset));
+    }
+
+    bool operator<(const StateSensorEntry& e) const
+    {
+        return (
+            (containerId < e.containerId) ||
+            ((containerId == e.containerId) && (entityType < e.entityType)) ||
+            ((containerId == e.containerId) && (entityType == e.entityType) &&
+             (entityInstance < e.entityInstance)) ||
+            ((containerId == e.containerId) && (entityType == e.entityType) &&
+             (entityInstance == e.entityInstance) &&
+             (sensorOffset < e.sensorOffset)));
+    }
+};
+
+using StateToDBusValue = std::map<pdr::EventState, pldm::utils::PropertyValue>;
+using EventDBusInfo = std::tuple<pldm::utils::DBusMapping, StateToDBusValue>;
+using EventMap = std::map<StateSensorEntry, EventDBusInfo>;
+using Json = nlohmann::json;
+
+/** @class StateSensorHandler
+ *
+ *  @brief Parses the event state sensor configuration JSON file and build
+ *         the lookup data structure, which can map the event state for a
+ *         sensor in the PlatformEventMessage command to a D-Bus property and
+ *         the property value.
+ */
+class StateSensorHandler
+{
+  public:
+    StateSensorHandler() = delete;
+
+    /** @brief Parse the event state sensor configuration JSON file and build
+     *         the lookup data stucture.
+     *
+     *  @param[in] dirPath - directory path which has the config JSONs
+     */
+    explicit StateSensorHandler(const std::string& dirPath);
+    virtual ~StateSensorHandler() = default;
+    StateSensorHandler(const StateSensorHandler&) = default;
+    StateSensorHandler& operator=(const StateSensorHandler&) = default;
+    StateSensorHandler(StateSensorHandler&&) = default;
+    StateSensorHandler& operator=(StateSensorHandler&&) = default;
+
+    /** @brief If the StateSensorEntry and EventState is valid, the D-Bus
+     *         property corresponding to the StateSensorEntry is set based on
+     *         the EventState
+     *
+     *  @param[in] entry - state sensor entry
+     *  @param[in] state - event state
+     *
+     *  @return PLDM completion code
+     */
+    int eventAction(const StateSensorEntry& entry, pdr::EventState state);
+
+    /** @brief Helper API to get D-Bus information for a StateSensorEntry
+     *
+     *  @param[in] entry - state sensor entry
+     *
+     *  @return D-Bus information corresponding to the SensorEntry
+     */
+    const EventDBusInfo& getEventInfo(const StateSensorEntry& entry) const
+    {
+        return eventMap.at(entry);
+    }
+
+  private:
+    EventMap eventMap; //!< a map of StateSensorEntry to D-Bus information
+
+    /** @brief Create a map of EventState to D-Bus property values from
+     *         the information provided in the event state configuration
+     *         JSON
+     *
+     *  @param[in] eventStates - a JSON array of event states
+     *  @param[in] propertyValues - a JSON array of D-Bus property values
+     *  @param[in] type - the type of D-Bus property
+     *
+     *  @return a map of EventState to D-Bus property values
+     */
+    StateToDBusValue mapStateToDBusVal(const Json& eventStates,
+                                       const Json& propertyValues,
+                                       std::string_view type);
+};
+
+} // namespace pldm::responder::events
\ No newline at end of file
diff --git a/libpldmresponder/examples/events/event_state_sensor.json b/libpldmresponder/examples/events/event_state_sensor.json
new file mode 100644
index 0000000..47713b8
--- /dev/null
+++ b/libpldmresponder/examples/events/event_state_sensor.json
@@ -0,0 +1,69 @@
+# Each entry is to uniquely identify a remote state sensor(there are separate
+# entry for each sensor in a composite sensor) and the supported event states.
+# The "dbus" section contains information about the corresponding D-Bus
+# property for the sensor and "property_values" are the D-Bus property values
+# for each corresponding entry in the "event_states"
+{
+    "entries": [
+        {
+            "containerID": 1,
+            "entityType": 64,
+            "entityInstance": 1,
+            "sensorOffset": 0,
+            "event_states": [
+                0,
+                1
+            ],
+            "dbus": {
+                "object_path": "/xyz/abc/def",
+                "interface": "xyz.openbmc_project.example1.value",
+                "property_name": "value1",
+                "property_type": "string",
+                "property_values": [
+                    "xyz.openbmc_project.State.On",
+                    "xyz.openbmc_project.State.Off"
+                ]
+            }
+        },
+        {
+            "containerID": 1,
+            "entityType": 64,
+            "entityInstance": 1,
+            "sensorOffset": 1,
+            "event_states": [
+                2,
+                3
+            ],
+            "dbus": {
+                "object_path": "/xyz/abc/def",
+                "interface": "xyz.openbmc_project.example2.value",
+                "property_name": "value2",
+                "property_type": "uint8_t",
+                "property_values": [
+                    9,
+                    10
+                ]
+            }
+        },
+        {
+            "containerID": 1,
+            "entityType": 67,
+            "entityInstance": 1,
+            "sensorOffset": 0,
+            "event_states": [
+                0,
+                1
+            ],
+            "dbus": {
+                "object_path": "/xyz/abc/ghi",
+                "interface": "xyz.openbmc_project.example3.value",
+                "property_name": "value3",
+                "property_type": "bool",
+                "property_values": [
+                    false,
+                    true
+                ]
+            }
+        }
+    ]
+}
diff --git a/libpldmresponder/meson.build b/libpldmresponder/meson.build
index 0275e94..8231630 100644
--- a/libpldmresponder/meson.build
+++ b/libpldmresponder/meson.build
@@ -20,7 +20,8 @@
   'platform.cpp',
   'fru_parser.cpp',
   'fru.cpp',
-  '../host_pdr_handler.cpp'
+  '../host_pdr_handler.cpp',
+  'event_parser.cpp'
 ]
 
 if get_option('oem-ibm').enabled()
diff --git a/libpldmresponder/platform.hpp b/libpldmresponder/platform.hpp
index 1982031..a21502e 100644
--- a/libpldmresponder/platform.hpp
+++ b/libpldmresponder/platform.hpp
@@ -2,6 +2,7 @@
 
 #include "config.h"
 
+#include "event_parser.hpp"
 #include "handler.hpp"
 #include "host_pdr_handler.hpp"
 #include "libpldmresponder/pdr.hpp"
@@ -53,13 +54,13 @@
 class Handler : public CmdHandler
 {
   public:
-    Handler(const std::string& dir, pldm_pdr* repo,
-            HostPDRHandler* hostPDRHandler,
+    Handler(const std::string& pdrJsonsDir, const std::string& eventsJsonsDir,
+            pldm_pdr* repo, HostPDRHandler* hostPDRHandler,
             const std::optional<EventMap>& addOnHandlersMap = std::nullopt) :
         pdrRepo(repo),
-        hostPDRHandler(hostPDRHandler)
+        hostPDRHandler(hostPDRHandler), stateSensorHandler(eventsJsonsDir)
     {
-        generate(dir, pdrRepo);
+        generate(pdrJsonsDir, pdrRepo);
 
         handlers.emplace(PLDM_GET_PDR,
                          [this](const pldm_msg* request, size_t payloadLength) {
@@ -394,6 +395,7 @@
     uint16_t nextEffecterId{};
     DbusObjMaps dbusObjMaps{};
     HostPDRHandler* hostPDRHandler;
+    events::StateSensorHandler stateSensorHandler;
 };
 
 } // namespace platform
diff --git a/meson.build b/meson.build
index 23c3b72..88fe1d2 100644
--- a/meson.build
+++ b/meson.build
@@ -19,6 +19,7 @@
 conf_data.set_quoted('PDR_JSONS_DIR', '/usr/share/pldm/pdr')
 conf_data.set_quoted('FRU_JSONS_DIR', '/usr/share/pldm/fru')
 conf_data.set_quoted('HOST_JSONS_DIR', '/usr/share/pldm/host')
+conf_data.set_quoted('EVENTS_JSONS_DIR', '/usr/share/pldm/events')
 if get_option('oem-ibm').enabled()
   conf_data.set_quoted('FILE_TABLE_JSON', '/usr/share/pldm/fileTable.json')
   conf_data.set_quoted('LID_PERM_DIR', '/usr/share/host-fw')
diff --git a/pldmd.cpp b/pldmd.cpp
index eb882f4..d1ca6fa 100644
--- a/pldmd.cpp
+++ b/pldmd.cpp
@@ -179,9 +179,10 @@
     Invoker invoker{};
     invoker.registerHandler(PLDM_BASE, std::make_unique<base::Handler>());
     invoker.registerHandler(PLDM_BIOS, std::make_unique<bios::Handler>());
-    invoker.registerHandler(
-        PLDM_PLATFORM, std::make_unique<platform::Handler>(
-                           PDR_JSONS_DIR, pdrRepo.get(), hostPDRHandler.get()));
+    invoker.registerHandler(PLDM_PLATFORM,
+                            std::make_unique<platform::Handler>(
+                                PDR_JSONS_DIR, EVENTS_JSONS_DIR, pdrRepo.get(),
+                                hostPDRHandler.get()));
     invoker.registerHandler(
         PLDM_FRU, std::make_unique<fru::Handler>(FRU_JSONS_DIR, pdrRepo.get(),
                                                  entityTree.get()));
diff --git a/test/event_jsons/good/event_state_sensor.json b/test/event_jsons/good/event_state_sensor.json
new file mode 100644
index 0000000..f10a319
--- /dev/null
+++ b/test/event_jsons/good/event_state_sensor.json
@@ -0,0 +1,66 @@
+{
+    "entries": [
+        {
+            "containerID": 1,
+            "entityType": 64,
+            "entityInstance": 1,
+            "sensorOffset": 0,
+            "event_states": [
+                0,
+                1,
+                2
+            ],
+            "dbus": {
+                "object_path": "/xyz/abc/def",
+                "interface": "xyz.openbmc_project.example1.value",
+                "property_name": "value1",
+                "property_type": "string",
+                "property_values": [
+                    "xyz.openbmc_project.State.Normal",
+                    "xyz.openbmc_project.State.Critical",
+                    "xyz.openbmc_project.State.Fatal"
+                ]
+            }
+        },
+        {
+            "containerID": 1,
+            "entityType": 64,
+            "entityInstance": 1,
+            "sensorOffset": 1,
+            "event_states": [
+                2,
+                3
+            ],
+            "dbus": {
+                "object_path": "/xyz/abc/def",
+                "interface": "xyz.openbmc_project.example2.value",
+                "property_name": "value2",
+                "property_type": "uint8_t",
+                "property_values": [
+                    9,
+                    10
+                ]
+            }
+        },
+        {
+            "containerID": 2,
+            "entityType": 67,
+            "entityInstance": 2,
+            "sensorOffset": 0,
+            "event_states": [
+                0,
+                1
+            ],
+            "dbus": {
+                "object_path": "/xyz/abc/ghi",
+                "interface": "xyz.openbmc_project.example3.value",
+                "property_name": "value3",
+                "property_type": "bool",
+                "property_values": [
+                    false,
+                    true
+                ]
+            }
+        }
+    ]
+}
diff --git a/test/event_jsons/malformed1/event_state.json b/test/event_jsons/malformed1/event_state.json
new file mode 100644
index 0000000..29f9b04
--- /dev/null
+++ b/test/event_jsons/malformed1/event_state.json
@@ -0,0 +1,26 @@
+{
+    "entries": [
+        {
+            "containerID": 1,
+            "entityType": 64,
+            "entityInstance": 1,
+            "sensorOffset": 1,
+            "event_states": [
+                0,
+                1,
+                2
+            ],
+            "dbus": {
+                "object_path": "/xyz/abc/def",
+                "interface": "xyz.openbmc_project.example1.value",
+                "property_name": "value1",
+                "property_type": "string",
+                "property_values": [
+                    "xyz.openbmc_project.State.Normal",
+                    "xyz.openbmc_project.State.Critical",
+                    "xyz.openbmc_project.State.Fatal"
+                ]
+            }
+        }
+    ]
+}
diff --git a/test/event_jsons/malformed2/event_state_sensor.json b/test/event_jsons/malformed2/event_state_sensor.json
new file mode 100644
index 0000000..f7de057
--- /dev/null
+++ b/test/event_jsons/malformed2/event_state_sensor.json
@@ -0,0 +1,26 @@
+{
+    "entries": [
+        {
+            "containerID": 1,
+            "entityType": 64,
+            "entityInstance": 1,
+            "sensorOffset": 1,
+            "event_states": [
+                0,
+                1,
+                2
+            ],
+            "dbus": {
+                "object_path": "/xyz/abc/def",
+                "interface": "xyz.openbmc_project.example1.value",
+                "property_name": "value1",
+                "property_type": "string",
+                "property_values": [
+                    "xyz.openbmc_project.State.Normal",
+                    "xyz.openbmc_project.State.Critical"
+                    "xyz.openbmc_project.State.Fatal"
+                ]
+            }
+        }
+    ]
+}
diff --git a/test/libpldmresponder_pdr_effecter_test.cpp b/test/libpldmresponder_pdr_effecter_test.cpp
index 72ca0c6..1bf2730 100644
--- a/test/libpldmresponder_pdr_effecter_test.cpp
+++ b/test/libpldmresponder_pdr_effecter_test.cpp
@@ -15,7 +15,8 @@
     auto inPDRRepo = pldm_pdr_init();
     auto outPDRRepo = pldm_pdr_init();
     Repo outRepo(outPDRRepo);
-    Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr);
+    Handler handler("./pdr_jsons/state_effecter/good", "./event_jsons/good",
+                    inPDRRepo, nullptr);
     Repo inRepo(inPDRRepo);
     getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR);
 
@@ -108,7 +109,7 @@
     auto inPDRRepo = pldm_pdr_init();
     auto outPDRRepo = pldm_pdr_init();
     Repo outRepo(outPDRRepo);
-    Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr);
+    Handler handler("./pdr_jsons/state_effecter/good", "", inPDRRepo, nullptr);
     Repo inRepo(inPDRRepo);
     getRepoByType(inRepo, outRepo, PLDM_NUMERIC_EFFECTER_PDR);
 
@@ -147,7 +148,8 @@
 {
     auto pdrRepo = pldm_pdr_init();
 
-    ASSERT_THROW(Handler("./pdr_jsons/not_there", pdrRepo, nullptr),
+    ASSERT_THROW(Handler("./pdr_jsons/not_there", "./event_jsons/not_there",
+                         pdrRepo, nullptr),
                  std::exception);
 
     pldm_pdr_destroy(pdrRepo);
@@ -158,7 +160,8 @@
     auto inPDRRepo = pldm_pdr_init();
     auto outPDRRepo = pldm_pdr_init();
     Repo outRepo(outPDRRepo);
-    Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr);
+    Handler handler("./pdr_jsons/state_effecter/good", "./event_jsons/good",
+                    inPDRRepo, nullptr);
     Repo inRepo(inPDRRepo);
     getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR);
 
diff --git a/test/libpldmresponder_platform_test.cpp b/test/libpldmresponder_platform_test.cpp
index 9af13d5..f487d3b 100644
--- a/test/libpldmresponder_platform_test.cpp
+++ b/test/libpldmresponder_platform_test.cpp
@@ -1,3 +1,4 @@
+#include "libpldmresponder/event_parser.hpp"
 #include "libpldmresponder/pdr.hpp"
 #include "libpldmresponder/pdr_utils.hpp"
 #include "libpldmresponder/platform.hpp"
@@ -26,7 +27,8 @@
     request->request_count = 100;
 
     auto pdrRepo = pldm_pdr_init();
-    Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr);
+    Handler handler("./pdr_jsons/state_effecter/good", "./event_jsons/good",
+                    pdrRepo, nullptr);
     Repo repo(pdrRepo);
     ASSERT_EQ(repo.empty(), false);
     auto response = handler.getPDR(req, requestPayloadLength);
@@ -57,7 +59,8 @@
     request->request_count = 1;
 
     auto pdrRepo = pldm_pdr_init();
-    Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr);
+    Handler handler("./pdr_jsons/state_effecter/good", "./event_jsons/good",
+                    pdrRepo, nullptr);
     Repo repo(pdrRepo);
     ASSERT_EQ(repo.empty(), false);
     auto response = handler.getPDR(req, requestPayloadLength);
@@ -82,7 +85,8 @@
     request->request_count = 1;
 
     auto pdrRepo = pldm_pdr_init();
-    Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr);
+    Handler handler("./pdr_jsons/state_effecter/good", "./event_jsons/good",
+                    pdrRepo, nullptr);
     Repo repo(pdrRepo);
     ASSERT_EQ(repo.empty(), false);
     auto response = handler.getPDR(req, requestPayloadLength);
@@ -105,7 +109,8 @@
     request->record_handle = 1;
 
     auto pdrRepo = pldm_pdr_init();
-    Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr);
+    Handler handler("./pdr_jsons/state_effecter/good", "./event_jsons/good",
+                    pdrRepo, nullptr);
     Repo repo(pdrRepo);
     ASSERT_EQ(repo.empty(), false);
     auto response = handler.getPDR(req, requestPayloadLength);
@@ -130,7 +135,8 @@
     request->request_count = 100;
 
     auto pdrRepo = pldm_pdr_init();
-    Handler handler("./pdr_jsons/state_effecter/good", pdrRepo, nullptr);
+    Handler handler("./pdr_jsons/state_effecter/good", "./event_jsons/good",
+                    pdrRepo, nullptr);
     Repo repo(pdrRepo);
     ASSERT_EQ(repo.empty(), false);
     auto response = handler.getPDR(req, requestPayloadLength);
@@ -181,7 +187,8 @@
     auto inPDRRepo = pldm_pdr_init();
     auto outPDRRepo = pldm_pdr_init();
     Repo outRepo(outPDRRepo);
-    Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr);
+    Handler handler("./pdr_jsons/state_effecter/good", "./event_jsons/good",
+                    inPDRRepo, nullptr);
     Repo inRepo(inPDRRepo);
     getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR);
     pdr_utils::PdrEntry e;
@@ -216,7 +223,8 @@
     auto inPDRRepo = pldm_pdr_init();
     auto outPDRRepo = pldm_pdr_init();
     Repo outRepo(outPDRRepo);
-    Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr);
+    Handler handler("./pdr_jsons/state_effecter/good", "./event_jsons/good",
+                    inPDRRepo, nullptr);
     Repo inRepo(inPDRRepo);
     getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR);
     pdr_utils::PdrEntry e;
@@ -255,7 +263,7 @@
     auto inPDRRepo = pldm_pdr_init();
     auto numericEffecterPdrRepo = pldm_pdr_init();
     Repo numericEffecterPDRs(numericEffecterPdrRepo);
-    Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr);
+    Handler handler("./pdr_jsons/state_effecter/good", "", inPDRRepo, nullptr);
     Repo inRepo(inPDRRepo);
     getRepoByType(inRepo, numericEffecterPDRs, PLDM_NUMERIC_EFFECTER_PDR);
 
@@ -292,7 +300,7 @@
     auto inPDRRepo = pldm_pdr_init();
     auto numericEffecterPdrRepo = pldm_pdr_init();
     Repo numericEffecterPDRs(numericEffecterPdrRepo);
-    Handler handler("./pdr_jsons/state_effecter/good", inPDRRepo, nullptr);
+    Handler handler("./pdr_jsons/state_effecter/good", "", inPDRRepo, nullptr);
     Repo inRepo(inPDRRepo);
     getRepoByType(inRepo, numericEffecterPDRs, PLDM_NUMERIC_EFFECTER_PDR);
 
@@ -384,3 +392,82 @@
     ASSERT_EQ(le16toh(entityInstance3), 2u);
     ASSERT_EQ(states3, statesCmp3);
 }
+
+TEST(StateSensorHandler, allScenarios)
+{
+    using namespace pldm::responder::events;
+
+    ASSERT_THROW(StateSensorHandler("./event_jsons/malformed1"),
+                 std::exception);
+    ASSERT_THROW(StateSensorHandler("./event_jsons/malformed2"),
+                 std::exception);
+
+    StateSensorHandler handler{"./event_jsons/good"};
+    constexpr uint8_t eventState0 = 0;
+    constexpr uint8_t eventState1 = 1;
+    constexpr uint8_t eventState2 = 2;
+    constexpr uint8_t eventState3 = 3;
+
+    // Event Entry 1
+    {
+        StateSensorEntry entry{1, 64, 1, 0};
+        const auto& [dbusMapping, eventStateMap] = handler.getEventInfo(entry);
+        DBusMapping mapping{"/xyz/abc/def",
+                            "xyz.openbmc_project.example1.value", "value1",
+                            "string"};
+        ASSERT_EQ(mapping == dbusMapping, true);
+
+        const auto& propValue0 = eventStateMap.at(eventState0);
+        const auto& propValue1 = eventStateMap.at(eventState1);
+        const auto& propValue2 = eventStateMap.at(eventState2);
+        PropertyValue value0{std::in_place_type<std::string>,
+                             "xyz.openbmc_project.State.Normal"};
+        PropertyValue value1{std::in_place_type<std::string>,
+                             "xyz.openbmc_project.State.Critical"};
+        PropertyValue value2{std::in_place_type<std::string>,
+                             "xyz.openbmc_project.State.Fatal"};
+        ASSERT_EQ(value0 == propValue0, true);
+        ASSERT_EQ(value1 == propValue1, true);
+        ASSERT_EQ(value2 == propValue2, true);
+    }
+
+    // Event Entry 2
+    {
+        StateSensorEntry entry{1, 64, 1, 1};
+        const auto& [dbusMapping, eventStateMap] = handler.getEventInfo(entry);
+        DBusMapping mapping{"/xyz/abc/def",
+                            "xyz.openbmc_project.example2.value", "value2",
+                            "uint8_t"};
+        ASSERT_EQ(mapping == dbusMapping, true);
+
+        const auto& propValue0 = eventStateMap.at(eventState2);
+        const auto& propValue1 = eventStateMap.at(eventState3);
+        PropertyValue value0{std::in_place_type<uint8_t>, 9};
+        PropertyValue value1{std::in_place_type<uint8_t>, 10};
+        ASSERT_EQ(value0 == propValue0, true);
+        ASSERT_EQ(value1 == propValue1, true);
+    }
+
+    // Event Entry 3
+    {
+        StateSensorEntry entry{2, 67, 2, 0};
+        const auto& [dbusMapping, eventStateMap] = handler.getEventInfo(entry);
+        DBusMapping mapping{"/xyz/abc/ghi",
+                            "xyz.openbmc_project.example3.value", "value3",
+                            "bool"};
+        ASSERT_EQ(mapping == dbusMapping, true);
+
+        const auto& propValue0 = eventStateMap.at(eventState0);
+        const auto& propValue1 = eventStateMap.at(eventState1);
+        PropertyValue value0{std::in_place_type<bool>, false};
+        PropertyValue value1{std::in_place_type<bool>, true};
+        ASSERT_EQ(value0 == propValue0, true);
+        ASSERT_EQ(value1 == propValue1, true);
+    }
+
+    // Invalid Entry
+    {
+        StateSensorEntry entry{0, 0, 0, 0};
+        ASSERT_THROW(handler.getEventInfo(entry), std::out_of_range);
+    }
+}
diff --git a/types.hpp b/types.hpp
index e194c94..d701cfc 100644
--- a/types.hpp
+++ b/types.hpp
@@ -34,6 +34,8 @@
 using EntityInstance = uint16_t;
 using ContainerID = uint16_t;
 using CompositeCount = uint8_t;
+using SensorOffset = uint8_t;
+using EventState = uint8_t;
 
 //!< Subset of the State Set that is supported by a effecter/sensor
 using PossibleStates = std::set<uint8_t>;
diff --git a/utils.cpp b/utils.cpp
index 98e8d21..6a93d99 100644
--- a/utils.cpp
+++ b/utils.cpp
@@ -229,5 +229,57 @@
     return value;
 }
 
+PropertyValue jsonEntryToDbusVal(std::string_view type,
+                                 const nlohmann::json& value)
+{
+    PropertyValue propValue{};
+    if (type == "uint8_t")
+    {
+        propValue = static_cast<uint8_t>(value);
+    }
+    else if (type == "uint16_t")
+    {
+        propValue = static_cast<uint16_t>(value);
+    }
+    else if (type == "uint32_t")
+    {
+        propValue = static_cast<uint32_t>(value);
+    }
+    else if (type == "uint64_t")
+    {
+        propValue = static_cast<uint64_t>(value);
+    }
+    else if (type == "int16_t")
+    {
+        propValue = static_cast<int16_t>(value);
+    }
+    else if (type == "int32_t")
+    {
+        propValue = static_cast<int32_t>(value);
+    }
+    else if (type == "int64_t")
+    {
+        propValue = static_cast<int64_t>(value);
+    }
+    else if (type == "bool")
+    {
+        propValue = static_cast<bool>(value);
+    }
+    else if (type == "double")
+    {
+        propValue = static_cast<double>(value);
+    }
+    else if (type == "string")
+    {
+        propValue = static_cast<std::string>(value);
+    }
+    else
+    {
+        std::cerr << "Unknown D-Bus property type, TYPE=" << type << "\n";
+    }
+
+    return propValue;
+}
+
 } // namespace utils
 } // namespace pldm
diff --git a/utils.hpp b/utils.hpp
index 6ac282d..abf525b 100644
--- a/utils.hpp
+++ b/utils.hpp
@@ -7,6 +7,7 @@
 #include <exception>
 #include <filesystem>
 #include <iostream>
+#include <nlohmann/json.hpp>
 #include <sdbusplus/server.hpp>
 #include <string>
 #include <variant>
@@ -248,6 +249,15 @@
  *  @return uint8_t - MCTP EID
  */
 uint8_t readHostEID();
+/** @brief Convert a value in the JSON to a D-Bus property value
+ *
+ *  @param[in] type - type of the D-Bus property
+ *  @param[in] value - value in the JSON file
+ *
+ *  @return PropertyValue - the D-Bus property value
+ */
+PropertyValue jsonEntryToDbusVal(std::string_view type,
+                                 const nlohmann::json& value);
 
 } // namespace utils
 } // namespace pldm