Move to Redfish 2026.2HEADmaster

Like we do, one line change and rerun the script.

2026.2 includes new properties and schemas.

The overview is at [1].

[1]: https://www.dmtf.org/sites/default/files/Redfish_Release_2026.2_Overview.pdf

Tested: Inspection only.

Change-Id: I860c142a3685b5aa98dfe27b2c718f16b04bece7
Signed-off-by: Gunnar Mills <gmills@us.ibm.com>

18 files changed, 525 insertions, 1 deletions

diff --git a/redfish-core/include/aggregation_utils.hpp b/redfish-core/include/aggregation_utils.hpp
index 3a88c22d56..bd8c89d4bf 100644
--- a/redfish-core/include/aggregation_utils.hpp
+++ b/redfish-core/include/aggregation_utils.hpp
@@ -20,7 +20,7 @@ namespace redfish
 {
 // 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, 58> topCollections{
+constexpr std::array<std::string_view, 59> topCollections{
     "/AggregationService/Aggregates",
     "/AggregationService/AggregationSources",
     "/AggregationService/ConnectionMethods",
@@ -47,6 +47,7 @@ constexpr std::array<std::string_view, 58> topCollections{
     "/LicenseService/Licenses",
     "/Managers",
     "/NVMeDomains",
+    "/PolicyService/Policies",
     "/PowerEquipment/ElectricalBuses",
     "/PowerEquipment/FloorPDUs",
     "/PowerEquipment/PowerShelves",
diff --git a/redfish-core/include/generated/enums/chassis.hpp b/redfish-core/include/generated/enums/chassis.hpp
index fe09bd3b1d..bc90d9a87c 100644
--- a/redfish-core/include/generated/enums/chassis.hpp
+++ b/redfish-core/include/generated/enums/chassis.hpp
@@ -88,6 +88,8 @@ enum class RackUnits{
 
 enum class RackMountWidth{
     Invalid,
+    OpenRack,
+    OpenRackWide,
     OpenU,
     EIA_310,
     EIA_310_Telco,
@@ -175,6 +177,8 @@ NLOHMANN_JSON_SERIALIZE_ENUM(RackUnits, {
 
 NLOHMANN_JSON_SERIALIZE_ENUM(RackMountWidth, {
     {RackMountWidth::Invalid, "Invalid"},
+    {RackMountWidth::OpenRack, "OpenRack"},
+    {RackMountWidth::OpenRackWide, "OpenRackWide"},
     {RackMountWidth::OpenU, "OpenU"},
     {RackMountWidth::EIA_310, "EIA_310"},
     {RackMountWidth::EIA_310_Telco, "EIA_310_Telco"},
diff --git a/redfish-core/include/generated/enums/circuit.hpp b/redfish-core/include/generated/enums/circuit.hpp
index b2b059ccda..4b80f2f0d2 100644
--- a/redfish-core/include/generated/enums/circuit.hpp
+++ b/redfish-core/include/generated/enums/circuit.hpp
@@ -55,6 +55,7 @@ enum class NominalVoltageType{
     AC400V,
     AC480V,
     DC48V,
+    OpenRackV3,
     DC240V,
     DC380V,
     DC400V,
@@ -119,6 +120,13 @@ enum class VoltageType{
     DC,
 };
 
+enum class PowerFlowDirection{
+    Invalid,
+    Source,
+    Load,
+    Bidirectional,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(PowerState, {
     {PowerState::Invalid, "Invalid"},
     {PowerState::On, "On"},
@@ -167,6 +175,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(NominalVoltageType, {
     {NominalVoltageType::AC400V, "AC400V"},
     {NominalVoltageType::AC480V, "AC480V"},
     {NominalVoltageType::DC48V, "DC48V"},
+    {NominalVoltageType::OpenRackV3, "OpenRackV3"},
     {NominalVoltageType::DC240V, "DC240V"},
     {NominalVoltageType::DC380V, "DC380V"},
     {NominalVoltageType::DC400V, "DC400V"},
@@ -231,5 +240,12 @@ NLOHMANN_JSON_SERIALIZE_ENUM(VoltageType, {
     {VoltageType::DC, "DC"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(PowerFlowDirection, {
+    {PowerFlowDirection::Invalid, "Invalid"},
+    {PowerFlowDirection::Source, "Source"},
+    {PowerFlowDirection::Load, "Load"},
+    {PowerFlowDirection::Bidirectional, "Bidirectional"},
+});
+
 // clang-format on
 } // namespace circuit
diff --git a/redfish-core/include/generated/enums/computer_system.hpp b/redfish-core/include/generated/enums/computer_system.hpp
index 9e3f0cd284..5a33da5801 100644
--- a/redfish-core/include/generated/enums/computer_system.hpp
+++ b/redfish-core/include/generated/enums/computer_system.hpp
@@ -243,6 +243,27 @@ enum class ImageChecksumAlgorithm{
     SHA256,
 };
 
+enum class ConsoleAuthenticationMethod{
+    Invalid,
+    ExplicitLogin,
+    OneTimeURL,
+    OneTimePassword,
+};
+
+enum class ConsoleAccessMode{
+    Invalid,
+    ReadWrite,
+    ReadOnly,
+};
+
+enum class GraphicalConsoleType{
+    Invalid,
+    VNC,
+    RDP,
+    HTML5,
+    KVMIP,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(BootSource, {
     {BootSource::Invalid, "Invalid"},
     {BootSource::None, "None"},
@@ -479,5 +500,26 @@ NLOHMANN_JSON_SERIALIZE_ENUM(ImageChecksumAlgorithm, {
     {ImageChecksumAlgorithm::SHA256, "SHA256"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(ConsoleAuthenticationMethod, {
+    {ConsoleAuthenticationMethod::Invalid, "Invalid"},
+    {ConsoleAuthenticationMethod::ExplicitLogin, "ExplicitLogin"},
+    {ConsoleAuthenticationMethod::OneTimeURL, "OneTimeURL"},
+    {ConsoleAuthenticationMethod::OneTimePassword, "OneTimePassword"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ConsoleAccessMode, {
+    {ConsoleAccessMode::Invalid, "Invalid"},
+    {ConsoleAccessMode::ReadWrite, "ReadWrite"},
+    {ConsoleAccessMode::ReadOnly, "ReadOnly"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(GraphicalConsoleType, {
+    {GraphicalConsoleType::Invalid, "Invalid"},
+    {GraphicalConsoleType::VNC, "VNC"},
+    {GraphicalConsoleType::RDP, "RDP"},
+    {GraphicalConsoleType::HTML5, "HTML5"},
+    {GraphicalConsoleType::KVMIP, "KVMIP"},
+});
+
 // clang-format on
 } // namespace computer_system
diff --git a/redfish-core/include/generated/enums/manager_network_protocol.hpp b/redfish-core/include/generated/enums/manager_network_protocol.hpp
index 8b78a351e4..e44b2ec2cc 100644
--- a/redfish-core/include/generated/enums/manager_network_protocol.hpp
+++ b/redfish-core/include/generated/enums/manager_network_protocol.hpp
@@ -58,6 +58,14 @@ enum class SSHPreferredAuthentication{
     HostBased,
 };
 
+enum class NTPState{
+    Invalid,
+    Synchronized,
+    NotSynchronized,
+    Disabled,
+    Unreachable,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(NotifyIPv6Scope, {
     {NotifyIPv6Scope::Invalid, "Invalid"},
     {NotifyIPv6Scope::Link, "Link"},
@@ -109,5 +117,13 @@ NLOHMANN_JSON_SERIALIZE_ENUM(SSHPreferredAuthentication, {
     {SSHPreferredAuthentication::HostBased, "HostBased"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(NTPState, {
+    {NTPState::Invalid, "Invalid"},
+    {NTPState::Synchronized, "Synchronized"},
+    {NTPState::NotSynchronized, "NotSynchronized"},
+    {NTPState::Disabled, "Disabled"},
+    {NTPState::Unreachable, "Unreachable"},
+});
+
 // clang-format on
 } // namespace manager_network_protocol
diff --git a/redfish-core/include/generated/enums/open_bmc_manager.hpp b/redfish-core/include/generated/enums/open_bmc_manager.hpp
new file mode 100644
index 0000000000..e9f70bdfd6
--- /dev/null
+++ b/redfish-core/include/generated/enums/open_bmc_manager.hpp
@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright OpenBMC Authors
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace open_bmc_manager
+{
+// clang-format off
+
+enum class HysteresisEvaluation{
+    Invalid,
+    Input,
+    Setpoint,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(HysteresisEvaluation, {
+    {HysteresisEvaluation::Invalid, "Invalid"},
+    {HysteresisEvaluation::Input, "Input"},
+    {HysteresisEvaluation::Setpoint, "Setpoint"},
+});
+
+// clang-format on
+} // namespace open_bmc_manager
diff --git a/redfish-core/include/generated/enums/pcie_device.hpp b/redfish-core/include/generated/enums/pcie_device.hpp
index ded55c3f10..8be1b61362 100644
--- a/redfish-core/include/generated/enums/pcie_device.hpp
+++ b/redfish-core/include/generated/enums/pcie_device.hpp
@@ -71,6 +71,14 @@ enum class CXLProtocolVersion{
     CXL3_2,
 };
 
+enum class CXLDeviceClass{
+    Invalid,
+    SLD,
+    MLD,
+    MH_SLD,
+    MH_MLD,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(PCIeTypes, {
     {PCIeTypes::Invalid, "Invalid"},
     {PCIeTypes::Gen1, "Gen1"},
@@ -135,5 +143,13 @@ NLOHMANN_JSON_SERIALIZE_ENUM(CXLProtocolVersion, {
     {CXLProtocolVersion::CXL3_2, "CXL3_2"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(CXLDeviceClass, {
+    {CXLDeviceClass::Invalid, "Invalid"},
+    {CXLDeviceClass::SLD, "SLD"},
+    {CXLDeviceClass::MLD, "MLD"},
+    {CXLDeviceClass::MH_SLD, "MH_SLD"},
+    {CXLDeviceClass::MH_MLD, "MH_MLD"},
+});
+
 // clang-format on
 } // namespace pcie_device
diff --git a/redfish-core/include/generated/enums/policy.hpp b/redfish-core/include/generated/enums/policy.hpp
new file mode 100644
index 0000000000..063791e8f3
--- /dev/null
+++ b/redfish-core/include/generated/enums/policy.hpp
@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright OpenBMC Authors
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace policy
+{
+// clang-format off
+
+enum class ConditionType{
+    Invalid,
+    And,
+    Or,
+    Compare,
+    Read,
+    Sum,
+    Average,
+    Event,
+};
+
+enum class ResponseAction{
+    Invalid,
+    Recheck,
+    Event,
+    Reset,
+    HTTP,
+    OEM,
+};
+
+enum class Operator{
+    Invalid,
+    Equal,
+    NotEqual,
+    GreaterThan,
+    LessThan,
+    GreaterThanOrEqual,
+    LessThanOrEqual,
+};
+
+enum class HTTPVerb{
+    Invalid,
+    GET,
+    PATCH,
+    POST,
+    DELETE,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ConditionType, {
+    {ConditionType::Invalid, "Invalid"},
+    {ConditionType::And, "And"},
+    {ConditionType::Or, "Or"},
+    {ConditionType::Compare, "Compare"},
+    {ConditionType::Read, "Read"},
+    {ConditionType::Sum, "Sum"},
+    {ConditionType::Average, "Average"},
+    {ConditionType::Event, "Event"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ResponseAction, {
+    {ResponseAction::Invalid, "Invalid"},
+    {ResponseAction::Recheck, "Recheck"},
+    {ResponseAction::Event, "Event"},
+    {ResponseAction::Reset, "Reset"},
+    {ResponseAction::HTTP, "HTTP"},
+    {ResponseAction::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(Operator, {
+    {Operator::Invalid, "Invalid"},
+    {Operator::Equal, "Equal"},
+    {Operator::NotEqual, "NotEqual"},
+    {Operator::GreaterThan, "GreaterThan"},
+    {Operator::LessThan, "LessThan"},
+    {Operator::GreaterThanOrEqual, "GreaterThanOrEqual"},
+    {Operator::LessThanOrEqual, "LessThanOrEqual"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(HTTPVerb, {
+    {HTTPVerb::Invalid, "Invalid"},
+    {HTTPVerb::GET, "GET"},
+    {HTTPVerb::PATCH, "PATCH"},
+    {HTTPVerb::POST, "POST"},
+    {HTTPVerb::DELETE, "DELETE"},
+});
+
+// clang-format on
+} // namespace policy
diff --git a/redfish-core/include/generated/enums/policy_service.hpp b/redfish-core/include/generated/enums/policy_service.hpp
new file mode 100644
index 0000000000..1de376d081
--- /dev/null
+++ b/redfish-core/include/generated/enums/policy_service.hpp
@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright OpenBMC Authors
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace policy_service
+{
+// clang-format off
+
+enum class OperatingMode{
+    Invalid,
+    Disabled,
+    AlertOnly,
+    Enabled,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(OperatingMode, {
+    {OperatingMode::Invalid, "Invalid"},
+    {OperatingMode::Disabled, "Disabled"},
+    {OperatingMode::AlertOnly, "AlertOnly"},
+    {OperatingMode::Enabled, "Enabled"},
+});
+
+// clang-format on
+} // namespace policy_service
diff --git a/redfish-core/include/generated/enums/port.hpp b/redfish-core/include/generated/enums/port.hpp
index f3399dc387..1437d273eb 100644
--- a/redfish-core/include/generated/enums/port.hpp
+++ b/redfish-core/include/generated/enums/port.hpp
@@ -219,6 +219,79 @@ enum class PoEDetectionStatus{
     OtherFault,
 };
 
+enum class UALink128GExtendedSpeedMode{
+    Invalid,
+    NoESM,
+    UALink128GExtendedSpeedMode104G,
+    UALink128GExtendedSpeedMode112G,
+    UALink128GExtendedSpeedMode120G,
+    UALink128GExtendedSpeedMode128G,
+};
+
+enum class UALink200GSerialRate{
+    Invalid,
+    UALink200GSerialRate100G,
+    UALink200GSerialRate200G,
+};
+
+enum class UALink200GCodewordInterleave{
+    Invalid,
+    OneWay,
+    TwoWay,
+    FourWay,
+};
+
+enum class UALinkPLState{
+    Invalid,
+    Idle,
+    TrainingInProgress,
+    TrainingFailed,
+    TrainingTimeout,
+    Up,
+};
+
+enum class UALinkDLState{
+    Invalid,
+    Idle,
+    NOP,
+    Fault,
+    PowerDown,
+    Up,
+};
+
+enum class UALinkTLState{
+    Invalid,
+    DropMode,
+    Enabled,
+};
+
+enum class UALinkUPLIOriginatorState{
+    Invalid,
+    DropMode,
+    IsolationMode,
+    Enabled,
+};
+
+enum class UALinkUPLICompleterState{
+    Invalid,
+    DropMode,
+    Enabled,
+};
+
+enum class PartnerDeviceType{
+    Invalid,
+    Switch,
+    Endpoint,
+};
+
+enum class PartnerValidationState{
+    Disabled,
+    LinkDown,
+    Discovering,
+    Invalid,
+    Validated,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(PortType, {
     {PortType::Invalid, "Invalid"},
     {PortType::UpstreamPort, "UpstreamPort"},
@@ -431,5 +504,78 @@ NLOHMANN_JSON_SERIALIZE_ENUM(PoEDetectionStatus, {
     {PoEDetectionStatus::OtherFault, "OtherFault"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(UALink128GExtendedSpeedMode, {
+    {UALink128GExtendedSpeedMode::Invalid, "Invalid"},
+    {UALink128GExtendedSpeedMode::NoESM, "NoESM"},
+    {UALink128GExtendedSpeedMode::UALink128GExtendedSpeedMode104G, "104G"},
+    {UALink128GExtendedSpeedMode::UALink128GExtendedSpeedMode112G, "112G"},
+    {UALink128GExtendedSpeedMode::UALink128GExtendedSpeedMode120G, "120G"},
+    {UALink128GExtendedSpeedMode::UALink128GExtendedSpeedMode128G, "128G"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(UALink200GSerialRate, {
+    {UALink200GSerialRate::Invalid, "Invalid"},
+    {UALink200GSerialRate::UALink200GSerialRate100G, "100G"},
+    {UALink200GSerialRate::UALink200GSerialRate200G, "200G"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(UALink200GCodewordInterleave, {
+    {UALink200GCodewordInterleave::Invalid, "Invalid"},
+    {UALink200GCodewordInterleave::OneWay, "OneWay"},
+    {UALink200GCodewordInterleave::TwoWay, "TwoWay"},
+    {UALink200GCodewordInterleave::FourWay, "FourWay"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(UALinkPLState, {
+    {UALinkPLState::Invalid, "Invalid"},
+    {UALinkPLState::Idle, "Idle"},
+    {UALinkPLState::TrainingInProgress, "TrainingInProgress"},
+    {UALinkPLState::TrainingFailed, "TrainingFailed"},
+    {UALinkPLState::TrainingTimeout, "TrainingTimeout"},
+    {UALinkPLState::Up, "Up"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(UALinkDLState, {
+    {UALinkDLState::Invalid, "Invalid"},
+    {UALinkDLState::Idle, "Idle"},
+    {UALinkDLState::NOP, "NOP"},
+    {UALinkDLState::Fault, "Fault"},
+    {UALinkDLState::PowerDown, "PowerDown"},
+    {UALinkDLState::Up, "Up"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(UALinkTLState, {
+    {UALinkTLState::Invalid, "Invalid"},
+    {UALinkTLState::DropMode, "DropMode"},
+    {UALinkTLState::Enabled, "Enabled"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(UALinkUPLIOriginatorState, {
+    {UALinkUPLIOriginatorState::Invalid, "Invalid"},
+    {UALinkUPLIOriginatorState::DropMode, "DropMode"},
+    {UALinkUPLIOriginatorState::IsolationMode, "IsolationMode"},
+    {UALinkUPLIOriginatorState::Enabled, "Enabled"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(UALinkUPLICompleterState, {
+    {UALinkUPLICompleterState::Invalid, "Invalid"},
+    {UALinkUPLICompleterState::DropMode, "DropMode"},
+    {UALinkUPLICompleterState::Enabled, "Enabled"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PartnerDeviceType, {
+    {PartnerDeviceType::Invalid, "Invalid"},
+    {PartnerDeviceType::Switch, "Switch"},
+    {PartnerDeviceType::Endpoint, "Endpoint"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PartnerValidationState, {
+    {PartnerValidationState::Disabled, "Disabled"},
+    {PartnerValidationState::LinkDown, "LinkDown"},
+    {PartnerValidationState::Discovering, "Discovering"},
+    {PartnerValidationState::Invalid, "Invalid"},
+    {PartnerValidationState::Validated, "Validated"},
+});
+
 // clang-format on
 } // namespace port
diff --git a/redfish-core/include/generated/enums/power_distribution.hpp b/redfish-core/include/generated/enums/power_distribution.hpp
index 64491e87b9..12cd943371 100644
--- a/redfish-core/include/generated/enums/power_distribution.hpp
+++ b/redfish-core/include/generated/enums/power_distribution.hpp
@@ -7,6 +7,13 @@ namespace power_distribution
 {
 // clang-format off
 
+enum class PowerState{
+    Invalid,
+    On,
+    Off,
+    PowerCycle,
+};
+
 enum class PowerEquipmentType{
     Invalid,
     RackPDU,
@@ -47,6 +54,13 @@ enum class ExportSecurity{
     ExcludeSensitiveData,
 };
 
+NLOHMANN_JSON_SERIALIZE_ENUM(PowerState, {
+    {PowerState::Invalid, "Invalid"},
+    {PowerState::On, "On"},
+    {PowerState::Off, "Off"},
+    {PowerState::PowerCycle, "PowerCycle"},
+});
+
 NLOHMANN_JSON_SERIALIZE_ENUM(PowerEquipmentType, {
     {PowerEquipmentType::Invalid, "Invalid"},
     {PowerEquipmentType::RackPDU, "RackPDU"},
diff --git a/redfish-core/include/generated/enums/power_subsystem.hpp b/redfish-core/include/generated/enums/power_subsystem.hpp
new file mode 100644
index 0000000000..703177311e
--- /dev/null
+++ b/redfish-core/include/generated/enums/power_subsystem.hpp
@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright OpenBMC Authors
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace power_subsystem
+{
+// clang-format off
+
+enum class ThresholdLevel{
+    Invalid,
+    Disabled,
+    UpperCaution,
+    UpperCritical,
+};
+
+enum class PowerBrakeReason{
+    Invalid,
+    LoadPercent,
+    Temperature,
+    LossOfComms,
+    ExternalSignal,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ThresholdLevel, {
+    {ThresholdLevel::Invalid, "Invalid"},
+    {ThresholdLevel::Disabled, "Disabled"},
+    {ThresholdLevel::UpperCaution, "UpperCaution"},
+    {ThresholdLevel::UpperCritical, "UpperCritical"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PowerBrakeReason, {
+    {PowerBrakeReason::Invalid, "Invalid"},
+    {PowerBrakeReason::LoadPercent, "LoadPercent"},
+    {PowerBrakeReason::Temperature, "Temperature"},
+    {PowerBrakeReason::LossOfComms, "LossOfComms"},
+    {PowerBrakeReason::ExternalSignal, "ExternalSignal"},
+});
+
+// clang-format on
+} // namespace power_subsystem
diff --git a/redfish-core/include/generated/enums/power_supply.hpp b/redfish-core/include/generated/enums/power_supply.hpp
index e7103b3b56..9c599d3bd2 100644
--- a/redfish-core/include/generated/enums/power_supply.hpp
+++ b/redfish-core/include/generated/enums/power_supply.hpp
@@ -13,6 +13,7 @@ enum class PowerSupplyType{
     DC,
     ACorDC,
     DCRegulator,
+    PSU,
 };
 
 enum class LineStatus{
@@ -28,6 +29,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(PowerSupplyType, {
     {PowerSupplyType::DC, "DC"},
     {PowerSupplyType::ACorDC, "ACorDC"},
     {PowerSupplyType::DCRegulator, "DCRegulator"},
+    {PowerSupplyType::PSU, "PSU"},
 });
 
 NLOHMANN_JSON_SERIALIZE_ENUM(LineStatus, {
diff --git a/redfish-core/include/generated/enums/sensor.hpp b/redfish-core/include/generated/enums/sensor.hpp
index 098e81aa62..84f1555ec3 100644
--- a/redfish-core/include/generated/enums/sensor.hpp
+++ b/redfish-core/include/generated/enums/sensor.hpp
@@ -75,6 +75,9 @@ enum class ReadingType{
     RotationalVelocity,
     RotationalAcceleration,
     Valve,
+    Turbidity,
+    LiquidConductivity,
+    pH,
 };
 
 enum class ImplementationType{
@@ -159,6 +162,9 @@ NLOHMANN_JSON_SERIALIZE_ENUM(ReadingType, {
     {ReadingType::RotationalVelocity, "RotationalVelocity"},
     {ReadingType::RotationalAcceleration, "RotationalAcceleration"},
     {ReadingType::Valve, "Valve"},
+    {ReadingType::Turbidity, "Turbidity"},
+    {ReadingType::LiquidConductivity, "LiquidConductivity"},
+    {ReadingType::pH, "pH"},
 });
 
 NLOHMANN_JSON_SERIALIZE_ENUM(ImplementationType, {
diff --git a/redfish-core/include/generated/enums/software_inventory.hpp b/redfish-core/include/generated/enums/software_inventory.hpp
index 943af036d6..685fe072d6 100644
--- a/redfish-core/include/generated/enums/software_inventory.hpp
+++ b/redfish-core/include/generated/enums/software_inventory.hpp
@@ -21,6 +21,15 @@ enum class ReleaseType{
     Other,
 };
 
+enum class ImageState{
+    Invalid,
+    Active,
+    Staged,
+    Armed,
+    TargetSpecific,
+    OEM,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(VersionScheme, {
     {VersionScheme::Invalid, "Invalid"},
     {VersionScheme::SemVer, "SemVer"},
@@ -35,5 +44,14 @@ NLOHMANN_JSON_SERIALIZE_ENUM(ReleaseType, {
     {ReleaseType::Other, "Other"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(ImageState, {
+    {ImageState::Invalid, "Invalid"},
+    {ImageState::Active, "Active"},
+    {ImageState::Staged, "Staged"},
+    {ImageState::Armed, "Armed"},
+    {ImageState::TargetSpecific, "TargetSpecific"},
+    {ImageState::OEM, "OEM"},
+});
+
 // clang-format on
 } // namespace software_inventory
diff --git a/redfish-core/include/generated/enums/storage.hpp b/redfish-core/include/generated/enums/storage.hpp
index 5a37833833..7d82aadfb8 100644
--- a/redfish-core/include/generated/enums/storage.hpp
+++ b/redfish-core/include/generated/enums/storage.hpp
@@ -85,6 +85,15 @@ enum class NMVePersonalityKeyAlgorithm{
     HMAC_SHA384,
 };
 
+enum class ReservationCapabilities{
+    Invalid,
+    CompatibleReservationHandling,
+    SpecifyInitiatorPorts,
+    MultipleTargetPorts,
+    PersistThroughPowerLoss,
+    SupportClearReservationsOutOfBand,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(ResetToDefaultsType, {
     {ResetToDefaultsType::Invalid, "Invalid"},
     {ResetToDefaultsType::ResetAll, "ResetAll"},
@@ -163,5 +172,14 @@ NLOHMANN_JSON_SERIALIZE_ENUM(NMVePersonalityKeyAlgorithm, {
     {NMVePersonalityKeyAlgorithm::HMAC_SHA384, "HMAC_SHA384"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(ReservationCapabilities, {
+    {ReservationCapabilities::Invalid, "Invalid"},
+    {ReservationCapabilities::CompatibleReservationHandling, "CompatibleReservationHandling"},
+    {ReservationCapabilities::SpecifyInitiatorPorts, "SpecifyInitiatorPorts"},
+    {ReservationCapabilities::MultipleTargetPorts, "MultipleTargetPorts"},
+    {ReservationCapabilities::PersistThroughPowerLoss, "PersistThroughPowerLoss"},
+    {ReservationCapabilities::SupportClearReservationsOutOfBand, "SupportClearReservationsOutOfBand"},
+});
+
 // clang-format on
 } // namespace storage
diff --git a/redfish-core/include/generated/enums/update_service_capabilities.hpp b/redfish-core/include/generated/enums/update_service_capabilities.hpp
new file mode 100644
index 0000000000..645b5362fa
--- /dev/null
+++ b/redfish-core/include/generated/enums/update_service_capabilities.hpp
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright OpenBMC Authors
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace update_service_capabilities
+{
+// clang-format off
+
+enum class AllowableTargetReferenceType{
+    Invalid,
+    SoftwareInventory,
+    DeviceResource,
+    ResourceCollection,
+    Aggregate,
+    ComputerSystem,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(AllowableTargetReferenceType, {
+    {AllowableTargetReferenceType::Invalid, "Invalid"},
+    {AllowableTargetReferenceType::SoftwareInventory, "SoftwareInventory"},
+    {AllowableTargetReferenceType::DeviceResource, "DeviceResource"},
+    {AllowableTargetReferenceType::ResourceCollection, "ResourceCollection"},
+    {AllowableTargetReferenceType::Aggregate, "Aggregate"},
+    {AllowableTargetReferenceType::ComputerSystem, "ComputerSystem"},
+});
+
+// clang-format on
+} // namespace update_service_capabilities
diff --git a/redfish-core/include/generated/enums/volume.hpp b/redfish-core/include/generated/enums/volume.hpp
index 2691cb3257..9b7762ccfc 100644
--- a/redfish-core/include/generated/enums/volume.hpp
+++ b/redfish-core/include/generated/enums/volume.hpp
@@ -151,6 +151,16 @@ enum class LBARelativePerformanceType{
     Degraded,
 };
 
+enum class ReservationType{
+    Invalid,
+    WriteExclusive,
+    ExclusiveAccess,
+    WriteExclusiveRegistrantsOnly,
+    ExclusiveAccessRegistrantsOnly,
+    WriteExclusiveAllRegistrants,
+    ExclusiveAccessAllRegistrants,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(InitializeType, {
     {InitializeType::Invalid, "Invalid"},
     {InitializeType::Fast, "Fast"},
@@ -295,5 +305,15 @@ NLOHMANN_JSON_SERIALIZE_ENUM(LBARelativePerformanceType, {
     {LBARelativePerformanceType::Degraded, "Degraded"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(ReservationType, {
+    {ReservationType::Invalid, "Invalid"},
+    {ReservationType::WriteExclusive, "WriteExclusive"},
+    {ReservationType::ExclusiveAccess, "ExclusiveAccess"},
+    {ReservationType::WriteExclusiveRegistrantsOnly, "WriteExclusiveRegistrantsOnly"},
+    {ReservationType::ExclusiveAccessRegistrantsOnly, "ExclusiveAccessRegistrantsOnly"},
+    {ReservationType::WriteExclusiveAllRegistrants, "WriteExclusiveAllRegistrants"},
+    {ReservationType::ExclusiveAccessAllRegistrants, "ExclusiveAccessAllRegistrants"},
+});
+
 // clang-format on
 } // namespace volume