diff --git a/include/Thresholds.hpp b/include/Thresholds.hpp
index 56bb541..183fa34 100644
--- a/include/Thresholds.hpp
+++ b/include/Thresholds.hpp
@@ -127,13 +127,6 @@
     Sensor* sensor;
 };
 
-// The common scheme for sysfs files naming is: <type><number>_<item>.
-// This function returns optionally these 3 elements as a tuple.
-std::optional<std::tuple<std::string, std::string, std::string>>
-    splitFileName(const std::filesystem::path& filePath);
-std::optional<double> readFile(const std::string& thresholdFile,
-                               const double& scaleFactor);
-
 bool parseThresholdsFromConfig(
     const SensorData& sensorData,
     std::vector<thresholds::Threshold>& thresholdVector,
diff --git a/include/Utils.hpp b/include/Utils.hpp
index 224842c..28a2df3 100644
--- a/include/Utils.hpp
+++ b/include/Utils.hpp
@@ -230,3 +230,10 @@
     std::function<void(ManagedObjectType& resp)> callback;
     ManagedObjectType respData;
 };
+
+// The common scheme for sysfs files naming is: <type><number>_<item>.
+// This function returns optionally these 3 elements as a tuple.
+std::optional<std::tuple<std::string, std::string, std::string>>
+    splitFileName(const std::filesystem::path& filePath);
+std::optional<double> readFile(const std::string& thresholdFile,
+                               const double& scaleFactor);
\ No newline at end of file
