diff --git a/redfish-core/include/aggregation_utils.hpp b/redfish-core/include/aggregation_utils.hpp
index 673b568..9b0d430 100644
--- a/redfish-core/include/aggregation_utils.hpp
+++ b/redfish-core/include/aggregation_utils.hpp
@@ -17,7 +17,7 @@
 {
 // Note that each URI actually begins with "/redfish/v1"
 // They've been omitted to save space and reduce search time
-constexpr std::array<std::string_view, 44> topCollections{
+constexpr std::array<std::string_view, 48> topCollections{
     "/AggregationService/Aggregates",
     "/AggregationService/AggregationSources",
     "/AggregationService/ConnectionMethods",
@@ -58,6 +58,10 @@
     "/TelemetryService/MetricReportDefinitions",
     "/TelemetryService/MetricReports",
     "/TelemetryService/Triggers",
+    "/ThermalEquipment/CDUs",
+    "/ThermalEquipment/CoolingLoops",
+    "/ThermalEquipment/HeatExchangers",
+    "/ThermalEquipment/ImmersionUnits",
     "/UpdateService/ClientCertificates",
     "/UpdateService/FirmwareInventory",
     "/UpdateService/RemoteServerCertificates",
diff --git a/redfish-core/include/generated/enums/chassis.hpp b/redfish-core/include/generated/enums/chassis.hpp
index cc0f9a7..267fc50 100644
--- a/redfish-core/include/generated/enums/chassis.hpp
+++ b/redfish-core/include/generated/enums/chassis.hpp
@@ -27,6 +27,8 @@
     IPBasedDrive,
     RackGroup,
     StorageEnclosure,
+    ImmersionTank,
+    HeatExchanger,
     Other,
 };
 
@@ -89,6 +91,8 @@
     {ChassisType::IPBasedDrive, "IPBasedDrive"},
     {ChassisType::RackGroup, "RackGroup"},
     {ChassisType::StorageEnclosure, "StorageEnclosure"},
+    {ChassisType::ImmersionTank, "ImmersionTank"},
+    {ChassisType::HeatExchanger, "HeatExchanger"},
     {ChassisType::Other, "Other"},
 });
 
diff --git a/redfish-core/include/generated/enums/control.hpp b/redfish-core/include/generated/enums/control.hpp
index 0db080a..98f2e24 100644
--- a/redfish-core/include/generated/enums/control.hpp
+++ b/redfish-core/include/generated/enums/control.hpp
@@ -12,6 +12,8 @@
     Frequency,
     FrequencyMHz,
     Pressure,
+    PressurekPa,
+    Valve,
 };
 
 enum class SetPointType{
@@ -42,6 +44,8 @@
     {ControlType::Frequency, "Frequency"},
     {ControlType::FrequencyMHz, "FrequencyMHz"},
     {ControlType::Pressure, "Pressure"},
+    {ControlType::PressurekPa, "PressurekPa"},
+    {ControlType::Valve, "Valve"},
 });
 
 NLOHMANN_JSON_SERIALIZE_ENUM(SetPointType, {
diff --git a/redfish-core/include/generated/enums/coolant_connector.hpp b/redfish-core/include/generated/enums/coolant_connector.hpp
new file mode 100644
index 0000000..6e740e9
--- /dev/null
+++ b/redfish-core/include/generated/enums/coolant_connector.hpp
@@ -0,0 +1,27 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace coolant_connector
+{
+// clang-format off
+
+enum class CoolantConnectorType{
+    Invalid,
+    Pair,
+    Supply,
+    Return,
+    Inline,
+    Closed,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(CoolantConnectorType, {
+    {CoolantConnectorType::Invalid, "Invalid"},
+    {CoolantConnectorType::Pair, "Pair"},
+    {CoolantConnectorType::Supply, "Supply"},
+    {CoolantConnectorType::Return, "Return"},
+    {CoolantConnectorType::Inline, "Inline"},
+    {CoolantConnectorType::Closed, "Closed"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/cooling_loop.hpp b/redfish-core/include/generated/enums/cooling_loop.hpp
new file mode 100644
index 0000000..cd81612
--- /dev/null
+++ b/redfish-core/include/generated/enums/cooling_loop.hpp
@@ -0,0 +1,25 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace cooling_loop
+{
+// clang-format off
+
+enum class CoolantType{
+    Invalid,
+    Water,
+    Hydrocarbon,
+    Fluorocarbon,
+    Dielectric,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(CoolantType, {
+    {CoolantType::Invalid, "Invalid"},
+    {CoolantType::Water, "Water"},
+    {CoolantType::Hydrocarbon, "Hydrocarbon"},
+    {CoolantType::Fluorocarbon, "Fluorocarbon"},
+    {CoolantType::Dielectric, "Dielectric"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/cooling_unit.hpp b/redfish-core/include/generated/enums/cooling_unit.hpp
new file mode 100644
index 0000000..7ed8fc9
--- /dev/null
+++ b/redfish-core/include/generated/enums/cooling_unit.hpp
@@ -0,0 +1,23 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace cooling_unit
+{
+// clang-format off
+
+enum class CoolingEquipmentType{
+    Invalid,
+    CDU,
+    HeatExchanger,
+    ImmersionUnit,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(CoolingEquipmentType, {
+    {CoolingEquipmentType::Invalid, "Invalid"},
+    {CoolingEquipmentType::CDU, "CDU"},
+    {CoolingEquipmentType::HeatExchanger, "HeatExchanger"},
+    {CoolingEquipmentType::ImmersionUnit, "ImmersionUnit"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/event.hpp b/redfish-core/include/generated/enums/event.hpp
index a88bac3..ecfab7e 100644
--- a/redfish-core/include/generated/enums/event.hpp
+++ b/redfish-core/include/generated/enums/event.hpp
@@ -16,6 +16,16 @@
     Other,
 };
 
+enum class DiagnosticDataTypes{
+    Invalid,
+    Manager,
+    PreOS,
+    OS,
+    OEM,
+    CPER,
+    CPERSection,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(EventType, {
     {EventType::Invalid, "Invalid"},
     {EventType::StatusChange, "StatusChange"},
@@ -27,5 +37,15 @@
     {EventType::Other, "Other"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(DiagnosticDataTypes, {
+    {DiagnosticDataTypes::Invalid, "Invalid"},
+    {DiagnosticDataTypes::Manager, "Manager"},
+    {DiagnosticDataTypes::PreOS, "PreOS"},
+    {DiagnosticDataTypes::OS, "OS"},
+    {DiagnosticDataTypes::OEM, "OEM"},
+    {DiagnosticDataTypes::CPER, "CPER"},
+    {DiagnosticDataTypes::CPERSection, "CPERSection"},
+});
+
 }
 // clang-format on
diff --git a/redfish-core/include/generated/enums/leak_detector.hpp b/redfish-core/include/generated/enums/leak_detector.hpp
new file mode 100644
index 0000000..e5fd723
--- /dev/null
+++ b/redfish-core/include/generated/enums/leak_detector.hpp
@@ -0,0 +1,21 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace leak_detector
+{
+// clang-format off
+
+enum class LeakDetectorType{
+    Invalid,
+    Moisture,
+    FloatSwitch,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(LeakDetectorType, {
+    {LeakDetectorType::Invalid, "Invalid"},
+    {LeakDetectorType::Moisture, "Moisture"},
+    {LeakDetectorType::FloatSwitch, "FloatSwitch"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/outlet.hpp b/redfish-core/include/generated/enums/outlet.hpp
index 364515e..504bec1 100644
--- a/redfish-core/include/generated/enums/outlet.hpp
+++ b/redfish-core/include/generated/enums/outlet.hpp
@@ -5,6 +5,13 @@
 {
 // clang-format off
 
+enum class PowerState{
+    Invalid,
+    On,
+    Off,
+    PowerCycle,
+};
+
 enum class ReceptacleType{
     Invalid,
     NEMA_5_15R,
@@ -29,6 +36,13 @@
     DC,
 };
 
+NLOHMANN_JSON_SERIALIZE_ENUM(PowerState, {
+    {PowerState::Invalid, "Invalid"},
+    {PowerState::On, "On"},
+    {PowerState::Off, "Off"},
+    {PowerState::PowerCycle, "PowerCycle"},
+});
+
 NLOHMANN_JSON_SERIALIZE_ENUM(ReceptacleType, {
     {ReceptacleType::Invalid, "Invalid"},
     {ReceptacleType::NEMA_5_15R, "NEMA_5_15R"},
diff --git a/redfish-core/include/generated/enums/outlet_group.hpp b/redfish-core/include/generated/enums/outlet_group.hpp
new file mode 100644
index 0000000..d274635
--- /dev/null
+++ b/redfish-core/include/generated/enums/outlet_group.hpp
@@ -0,0 +1,23 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace outlet_group
+{
+// clang-format off
+
+enum class PowerState{
+    Invalid,
+    On,
+    Off,
+    PowerCycle,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PowerState, {
+    {PowerState::Invalid, "Invalid"},
+    {PowerState::On, "On"},
+    {PowerState::Off, "Off"},
+    {PowerState::PowerCycle, "PowerCycle"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/port.hpp b/redfish-core/include/generated/enums/port.hpp
index 7ad79b7..28a9e49 100644
--- a/redfish-core/include/generated/enums/port.hpp
+++ b/redfish-core/include/generated/enums/port.hpp
@@ -106,6 +106,8 @@
     QSFP28,
     QSFP56,
     MiniSASHD,
+    QSFPDD,
+    OSFP,
 };
 
 enum class MediumType{
@@ -264,6 +266,8 @@
     {SFPType::QSFP28, "QSFP28"},
     {SFPType::QSFP56, "QSFP56"},
     {SFPType::MiniSASHD, "MiniSASHD"},
+    {SFPType::QSFPDD, "QSFPDD"},
+    {SFPType::OSFP, "OSFP"},
 });
 
 NLOHMANN_JSON_SERIALIZE_ENUM(MediumType, {
diff --git a/redfish-core/include/generated/enums/processor.hpp b/redfish-core/include/generated/enums/processor.hpp
index fc8073c..2d7c8f7 100644
--- a/redfish-core/include/generated/enums/processor.hpp
+++ b/redfish-core/include/generated/enums/processor.hpp
@@ -85,6 +85,7 @@
     PowerLimit,
     ThermalLimit,
     ClockLimit,
+    ManagementDetectedFault,
     Unknown,
     OEM,
 };
@@ -169,6 +170,7 @@
     {ThrottleCause::PowerLimit, "PowerLimit"},
     {ThrottleCause::ThermalLimit, "ThermalLimit"},
     {ThrottleCause::ClockLimit, "ClockLimit"},
+    {ThrottleCause::ManagementDetectedFault, "ManagementDetectedFault"},
     {ThrottleCause::Unknown, "Unknown"},
     {ThrottleCause::OEM, "OEM"},
 });
diff --git a/redfish-core/include/generated/enums/pump.hpp b/redfish-core/include/generated/enums/pump.hpp
new file mode 100644
index 0000000..92c29f7
--- /dev/null
+++ b/redfish-core/include/generated/enums/pump.hpp
@@ -0,0 +1,21 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace pump
+{
+// clang-format off
+
+enum class PumpType{
+    Invalid,
+    Liquid,
+    Compressor,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PumpType, {
+    {PumpType::Invalid, "Invalid"},
+    {PumpType::Liquid, "Liquid"},
+    {PumpType::Compressor, "Compressor"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/reservoir.hpp b/redfish-core/include/generated/enums/reservoir.hpp
new file mode 100644
index 0000000..cc37687
--- /dev/null
+++ b/redfish-core/include/generated/enums/reservoir.hpp
@@ -0,0 +1,25 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace reservoir
+{
+// clang-format off
+
+enum class ReservoirType{
+    Invalid,
+    Reserve,
+    Overflow,
+    Inline,
+    Immersion,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ReservoirType, {
+    {ReservoirType::Invalid, "Invalid"},
+    {ReservoirType::Reserve, "Reserve"},
+    {ReservoirType::Overflow, "Overflow"},
+    {ReservoirType::Inline, "Inline"},
+    {ReservoirType::Immersion, "Immersion"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/sensor.hpp b/redfish-core/include/generated/enums/sensor.hpp
index 2f43e10..80534db 100644
--- a/redfish-core/include/generated/enums/sensor.hpp
+++ b/redfish-core/include/generated/enums/sensor.hpp
@@ -37,6 +37,7 @@
     Increasing,
     Decreasing,
     Either,
+    Disabled,
 };
 
 enum class ReadingType{
@@ -53,14 +54,18 @@
     Frequency,
     Pressure,
     PressurekPa,
+    PressurePa,
     LiquidLevel,
     Rotational,
     AirFlow,
+    AirFlowCMM,
     LiquidFlow,
+    LiquidFlowLPM,
     Barometric,
     Altitude,
     Percent,
     AbsoluteHumidity,
+    Heat,
 };
 
 enum class ImplementationType{
@@ -70,6 +75,13 @@
     Reported,
 };
 
+enum class ReadingBasisType{
+    Invalid,
+    Zero,
+    Delta,
+    Headroom,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(VoltageType, {
     {VoltageType::Invalid, "Invalid"},
     {VoltageType::AC, "AC"},
@@ -102,6 +114,7 @@
     {ThresholdActivation::Increasing, "Increasing"},
     {ThresholdActivation::Decreasing, "Decreasing"},
     {ThresholdActivation::Either, "Either"},
+    {ThresholdActivation::Disabled, "Disabled"},
 });
 
 NLOHMANN_JSON_SERIALIZE_ENUM(ReadingType, {
@@ -118,14 +131,18 @@
     {ReadingType::Frequency, "Frequency"},
     {ReadingType::Pressure, "Pressure"},
     {ReadingType::PressurekPa, "PressurekPa"},
+    {ReadingType::PressurePa, "PressurePa"},
     {ReadingType::LiquidLevel, "LiquidLevel"},
     {ReadingType::Rotational, "Rotational"},
     {ReadingType::AirFlow, "AirFlow"},
+    {ReadingType::AirFlowCMM, "AirFlowCMM"},
     {ReadingType::LiquidFlow, "LiquidFlow"},
+    {ReadingType::LiquidFlowLPM, "LiquidFlowLPM"},
     {ReadingType::Barometric, "Barometric"},
     {ReadingType::Altitude, "Altitude"},
     {ReadingType::Percent, "Percent"},
     {ReadingType::AbsoluteHumidity, "AbsoluteHumidity"},
+    {ReadingType::Heat, "Heat"},
 });
 
 NLOHMANN_JSON_SERIALIZE_ENUM(ImplementationType, {
@@ -135,5 +152,12 @@
     {ImplementationType::Reported, "Reported"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(ReadingBasisType, {
+    {ReadingBasisType::Invalid, "Invalid"},
+    {ReadingBasisType::Zero, "Zero"},
+    {ReadingBasisType::Delta, "Delta"},
+    {ReadingBasisType::Headroom, "Headroom"},
+});
+
 }
 // clang-format on
diff --git a/redfish-core/include/generated/enums/storage.hpp b/redfish-core/include/generated/enums/storage.hpp
index 3aa35e6..f918a08 100644
--- a/redfish-core/include/generated/enums/storage.hpp
+++ b/redfish-core/include/generated/enums/storage.hpp
@@ -25,6 +25,14 @@
     UseLocalKey,
 };
 
+enum class AutoVolumeCreate{
+    Invalid,
+    Disabled,
+    NonRAID,
+    RAID0,
+    RAID1,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(ResetToDefaultsType, {
     {ResetToDefaultsType::Invalid, "Invalid"},
     {ResetToDefaultsType::ResetAll, "ResetAll"},
@@ -45,5 +53,13 @@
     {EncryptionMode::UseLocalKey, "UseLocalKey"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(AutoVolumeCreate, {
+    {AutoVolumeCreate::Invalid, "Invalid"},
+    {AutoVolumeCreate::Disabled, "Disabled"},
+    {AutoVolumeCreate::NonRAID, "NonRAID"},
+    {AutoVolumeCreate::RAID0, "RAID0"},
+    {AutoVolumeCreate::RAID1, "RAID1"},
+});
+
 }
 // clang-format on
diff --git a/redfish-core/include/generated/enums/triggers.hpp b/redfish-core/include/generated/enums/triggers.hpp
index b272057..f4f9563 100644
--- a/redfish-core/include/generated/enums/triggers.hpp
+++ b/redfish-core/include/generated/enums/triggers.hpp
@@ -29,6 +29,7 @@
     Increasing,
     Decreasing,
     Either,
+    Disabled,
 };
 
 enum class DirectionOfCrossingEnum{
@@ -61,6 +62,7 @@
     {ThresholdActivation::Increasing, "Increasing"},
     {ThresholdActivation::Decreasing, "Decreasing"},
     {ThresholdActivation::Either, "Either"},
+    {ThresholdActivation::Disabled, "Disabled"},
 });
 
 NLOHMANN_JSON_SERIALIZE_ENUM(DirectionOfCrossingEnum, {
diff --git a/redfish-core/include/generated/enums/volume.hpp b/redfish-core/include/generated/enums/volume.hpp
index 1c94c5d..f9e323b 100644
--- a/redfish-core/include/generated/enums/volume.hpp
+++ b/redfish-core/include/generated/enums/volume.hpp
@@ -115,6 +115,39 @@
     LBAFormat15,
 };
 
+enum class NamespaceType{
+    Invalid,
+    Block,
+    KeyValue,
+    ZNS,
+    Computational,
+};
+
+enum class OperationType{
+    Invalid,
+    Deduplicate,
+    CheckConsistency,
+    Initialize,
+    Replicate,
+    Delete,
+    ChangeRAIDType,
+    Rebuild,
+    Encrypt,
+    Decrypt,
+    Resize,
+    Compress,
+    Sanitize,
+    Format,
+};
+
+enum class LBARelativePerformanceType{
+    Invalid,
+    Best,
+    Better,
+    Good,
+    Degraded,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(InitializeType, {
     {InitializeType::Invalid, "Invalid"},
     {InitializeType::Fast, "Fast"},
@@ -225,5 +258,38 @@
     {LBAFormatType::LBAFormat15, "LBAFormat15"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(NamespaceType, {
+    {NamespaceType::Invalid, "Invalid"},
+    {NamespaceType::Block, "Block"},
+    {NamespaceType::KeyValue, "KeyValue"},
+    {NamespaceType::ZNS, "ZNS"},
+    {NamespaceType::Computational, "Computational"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(OperationType, {
+    {OperationType::Invalid, "Invalid"},
+    {OperationType::Deduplicate, "Deduplicate"},
+    {OperationType::CheckConsistency, "CheckConsistency"},
+    {OperationType::Initialize, "Initialize"},
+    {OperationType::Replicate, "Replicate"},
+    {OperationType::Delete, "Delete"},
+    {OperationType::ChangeRAIDType, "ChangeRAIDType"},
+    {OperationType::Rebuild, "Rebuild"},
+    {OperationType::Encrypt, "Encrypt"},
+    {OperationType::Decrypt, "Decrypt"},
+    {OperationType::Resize, "Resize"},
+    {OperationType::Compress, "Compress"},
+    {OperationType::Sanitize, "Sanitize"},
+    {OperationType::Format, "Format"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(LBARelativePerformanceType, {
+    {LBARelativePerformanceType::Invalid, "Invalid"},
+    {LBARelativePerformanceType::Best, "Best"},
+    {LBARelativePerformanceType::Better, "Better"},
+    {LBARelativePerformanceType::Good, "Good"},
+    {LBARelativePerformanceType::Degraded, "Degraded"},
+});
+
 }
 // clang-format on