diff --git a/common/utils.hpp b/common/utils.hpp
index 9964188..358d0d7 100644
--- a/common/utils.hpp
+++ b/common/utils.hpp
@@ -72,6 +72,7 @@
 constexpr auto dbusProperties = "org.freedesktop.DBus.Properties";
 constexpr auto mapperService = ObjectMapper::default_service;
 constexpr auto inventoryPath = "/xyz/openbmc_project/inventory";
+
 /** @struct CustomFD
  *
  *  RAII wrapper for file descriptor.
@@ -174,7 +175,7 @@
 using PropertyValue =
     std::variant<bool, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t,
                  uint64_t, double, std::string, std::vector<uint8_t>,
-                 std::vector<std::string>>;
+                 std::vector<uint64_t>, std::vector<std::string>>;
 using DbusProp = std::string;
 using DbusChangedProps = std::map<DbusProp, PropertyValue>;
 using DBusInterfaceAdded = std::vector<
@@ -194,6 +195,8 @@
 using MapperServiceMap = std::vector<std::pair<ServiceName, Interfaces>>;
 using GetSubTreeResponse = std::vector<std::pair<ObjectPath, MapperServiceMap>>;
 using GetSubTreePathsResponse = std::vector<std::string>;
+using GetAssociatedSubTreeResponse =
+    std::map<std::string, std::map<std::string, std::vector<std::string>>>;
 using GetAncestorsResponse =
     std::vector<std::pair<ObjectPath, MapperServiceMap>>;
 using PropertyMap = std::map<std::string, PropertyValue>;
@@ -232,6 +235,11 @@
     virtual PropertyMap getDbusPropertiesVariant(
         const char* serviceName, const char* objPath,
         const char* dbusInterface) const = 0;
+
+    virtual GetAssociatedSubTreeResponse getAssociatedSubTree(
+        const sdbusplus::message::object_path& objectPath,
+        const sdbusplus::message::object_path& subtree, int depth,
+        const std::vector<std::string>& ifaceList) const = 0;
 };
 
 /**
@@ -362,6 +370,19 @@
         return std::get<Property>(VariantValue);
     }
 
+    /** @brief Get the associated subtree from the mapper
+     *
+     * @param[in] path - The D-Bus object path
+     *
+     * @param[in] interface - The D-Bus interface
+     *
+     * @return GetAssociatedSubtreeResponse - The associated subtree
+     */
+    GetAssociatedSubTreeResponse getAssociatedSubTree(
+        const sdbusplus::message::object_path& objectPath,
+        const sdbusplus::message::object_path& subtree, int depth,
+        const std::vector<std::string>& ifaceList) const override;
+
     /** @brief Set Dbus property
      *
      *  @param[in] dBusMap - Object path, property name, interface and property
