diff --git a/monitor/types.hpp b/monitor/types.hpp
index c827042..66f2dfe 100644
--- a/monitor/types.hpp
+++ b/monitor/types.hpp
@@ -2,6 +2,9 @@
 
 #include "trust_group.hpp"
 
+#include <nlohmann/json.hpp>
+#include <phosphor-logging/log.hpp>
+
 #include <experimental/optional>
 #include <functional>
 #include <string>
@@ -21,6 +24,66 @@
 using PropertyIdentity = std::tuple<std::string, std::string, std::string>;
 
 using PropertyValue = std::variant<bool, int64_t, std::string>;
+class JsonTypeHandler
+{
+    using json = nlohmann::json;
+
+  public:
+    /**
+     * @brief Determines the data type of a JSON configured parameter that is
+     * used as a variant within the fan monitor application and returns the
+     * value as that variant.
+     * @details Retrieves a JSON entry by the first derived data type that
+     * is not null. Expected data types should appear in a logical order of
+     * conversion. i.e.) uint and int could both be uint Alternatively, the
+     * expected data type can be given to force which supported data type
+     * the JSON entry should be retrieved as.
+     *
+     * @param[in] entry - A single JSON entry
+     * @param[in] type - (OPTIONAL) The preferred data type of the entry
+     *
+     * @return A `PropertyValue` variant containing the JSON entry's value
+     */
+    static const PropertyValue getPropValue(const json& entry,
+                                            const std::string& type = "")
+    {
+        PropertyValue value;
+        if (auto boolPtr = entry.get_ptr<const bool*>())
+        {
+            if (type.empty() || type == "bool")
+            {
+                value = *boolPtr;
+                return value;
+            }
+        }
+        if (auto int64Ptr = entry.get_ptr<const int64_t*>())
+        {
+            if (type.empty() || type == "int64_t")
+            {
+                value = *int64Ptr;
+                return value;
+            }
+        }
+        if (auto stringPtr = entry.get_ptr<const std::string*>())
+        {
+            if (type.empty() || type == "std::string")
+            {
+                value = *stringPtr;
+                return value;
+            }
+        }
+
+        phosphor::logging::log<phosphor::logging::level::ERR>(
+            "Unsupported data type for JSON entry's value",
+            phosphor::logging::entry("GIVEN_ENTRY_TYPE=%s", type.c_str()),
+            phosphor::logging::entry("JSON_ENTRY=%s", entry.dump().c_str()),
+            phosphor::logging::entry("SUPPORTED_TYPES=%s",
+                                     "{bool, int64_t, std::string}"));
+        throw std::runtime_error(
+            "Unsupported data type for JSON entry's value");
+    }
+};
+
 constexpr auto propIdentity = 0;
 constexpr auto propValue = 1;
 using PropertyState = std::pair<PropertyIdentity, PropertyValue>;