Update schemas to 2023.2

To quote from The Redfish release [1]

2022.3 Redfish Schema Bundle – This .zip file contains the current
versions of all Redfish schemas. The bundle includes 40 schema updates
and developer resources.
Added Compute Express Link (CXL) support (NEW)
Extensions to Fabric, PCIeDevice, Processor, Memory, ComputerSystem,
and Chassis schemas Defined by DMTF alliance partner Compute Express
Link (CXL) Consortium
Extensions to Fabric, PCIeDevice, Processor, Memory, ComputerSystem,
and Chassis schemas New CXLLogicalDevice schema
Added MultiFactorAuth to AccountService to configure a service for
multi-factor authentication
HTTP Basic authentication is not available for accounts configured
for multi-factor authentication
For client certificate authentication, the client provides their
identity certificate during TLS handshaking
For RSA SecurID, Google Authenticator, and Microsoft Authenticator,
clients provide a new Token property in the session creation request
Added Heater and HeaterMetrics resources

[1] https://www.dmtf.org/content/redfish-release-20223-now-available

Change-Id: Iefe80866bfb83e65ab98b2cf4ee2eacce5238c5b
Signed-off-by: Ed Tanous <ed@tanous.net>

16 files changed, 284 insertions, 1 deletions

diff --git a/redfish-core/include/aggregation_utils.hpp b/redfish-core/include/aggregation_utils.hpp
index 9b0d4303ac..f0b259eb9e 100644
--- a/redfish-core/include/aggregation_utils.hpp
+++ b/redfish-core/include/aggregation_utils.hpp
@@ -17,7 +17,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, 48> topCollections{
+constexpr std::array<std::string_view, 49> topCollections{
     "/AggregationService/Aggregates",
     "/AggregationService/AggregationSources",
     "/AggregationService/ConnectionMethods",
@@ -65,6 +65,7 @@ constexpr std::array<std::string_view, 48> topCollections{
     "/UpdateService/ClientCertificates",
     "/UpdateService/FirmwareInventory",
     "/UpdateService/RemoteServerCertificates",
+    "/UpdateService/RemoteServerSSHKeys",
     "/UpdateService/SoftwareInventory",
 };
 } // namespace redfish
diff --git a/redfish-core/include/generated/enums/account_service.hpp b/redfish-core/include/generated/enums/account_service.hpp
index f2156ada9f..1bbbd65291 100644
--- a/redfish-core/include/generated/enums/account_service.hpp
+++ b/redfish-core/include/generated/enums/account_service.hpp
@@ -12,6 +12,7 @@ enum class MFABypassType{
     GoogleAuthenticator,
     MicrosoftAuthenticator,
     ClientCertificate,
+    OneTimePasscode,
     OEM,
 };
 
@@ -70,6 +71,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(MFABypassType, {
     {MFABypassType::GoogleAuthenticator, "GoogleAuthenticator"},
     {MFABypassType::MicrosoftAuthenticator, "MicrosoftAuthenticator"},
     {MFABypassType::ClientCertificate, "ClientCertificate"},
+    {MFABypassType::OneTimePasscode, "OneTimePasscode"},
     {MFABypassType::OEM, "OEM"},
 });
 
diff --git a/redfish-core/include/generated/enums/certificate.hpp b/redfish-core/include/generated/enums/certificate.hpp
index 860319733d..d647bc5d40 100644
--- a/redfish-core/include/generated/enums/certificate.hpp
+++ b/redfish-core/include/generated/enums/certificate.hpp
@@ -39,6 +39,10 @@ enum class CertificateUsageType{
     Device,
     Platform,
     BIOS,
+    IDevID,
+    LDevID,
+    IAK,
+    LAK,
 };
 
 NLOHMANN_JSON_SERIALIZE_ENUM(CertificateType, {
@@ -75,6 +79,10 @@ NLOHMANN_JSON_SERIALIZE_ENUM(CertificateUsageType, {
     {CertificateUsageType::Device, "Device"},
     {CertificateUsageType::Platform, "Platform"},
     {CertificateUsageType::BIOS, "BIOS"},
+    {CertificateUsageType::IDevID, "IDevID"},
+    {CertificateUsageType::LDevID, "LDevID"},
+    {CertificateUsageType::IAK, "IAK"},
+    {CertificateUsageType::LAK, "LAK"},
 });
 
 }
diff --git a/redfish-core/include/generated/enums/chassis.hpp b/redfish-core/include/generated/enums/chassis.hpp
index 267fc5045e..9c3464956c 100644
--- a/redfish-core/include/generated/enums/chassis.hpp
+++ b/redfish-core/include/generated/enums/chassis.hpp
@@ -69,6 +69,14 @@ enum class ThermalDirection{
     Sealed,
 };
 
+enum class DoorState{
+    Invalid,
+    Locked,
+    Closed,
+    LockedAndOpen,
+    Open,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(ChassisType, {
     {ChassisType::Invalid, "Invalid"},
     {ChassisType::Rack, "Rack"},
@@ -133,5 +141,13 @@ NLOHMANN_JSON_SERIALIZE_ENUM(ThermalDirection, {
     {ThermalDirection::Sealed, "Sealed"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(DoorState, {
+    {DoorState::Invalid, "Invalid"},
+    {DoorState::Locked, "Locked"},
+    {DoorState::Closed, "Closed"},
+    {DoorState::LockedAndOpen, "LockedAndOpen"},
+    {DoorState::Open, "Open"},
+});
+
 }
 // clang-format on
diff --git a/redfish-core/include/generated/enums/computer_system.hpp b/redfish-core/include/generated/enums/computer_system.hpp
index c15b14e901..04ed6b3634 100644
--- a/redfish-core/include/generated/enums/computer_system.hpp
+++ b/redfish-core/include/generated/enums/computer_system.hpp
@@ -185,6 +185,17 @@ enum class KMIPCachePolicy{
     AfterFirstUse,
 };
 
+enum class DecommissionType{
+    Invalid,
+    All,
+    UserData,
+    ManagerConfig,
+    BIOSConfig,
+    NetworkConfig,
+    StorageConfig,
+    Logs,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(BootSource, {
     {BootSource::Invalid, "Invalid"},
     {BootSource::None, "None"},
@@ -365,5 +376,16 @@ NLOHMANN_JSON_SERIALIZE_ENUM(KMIPCachePolicy, {
     {KMIPCachePolicy::AfterFirstUse, "AfterFirstUse"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(DecommissionType, {
+    {DecommissionType::Invalid, "Invalid"},
+    {DecommissionType::All, "All"},
+    {DecommissionType::UserData, "UserData"},
+    {DecommissionType::ManagerConfig, "ManagerConfig"},
+    {DecommissionType::BIOSConfig, "BIOSConfig"},
+    {DecommissionType::NetworkConfig, "NetworkConfig"},
+    {DecommissionType::StorageConfig, "StorageConfig"},
+    {DecommissionType::Logs, "Logs"},
+});
+
 }
 // clang-format on
diff --git a/redfish-core/include/generated/enums/container_image.hpp b/redfish-core/include/generated/enums/container_image.hpp
new file mode 100644
index 0000000000..c82d0d8277
--- /dev/null
+++ b/redfish-core/include/generated/enums/container_image.hpp
@@ -0,0 +1,23 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace container_image
+{
+// clang-format off
+
+enum class ImageTypes{
+    Invalid,
+    DockerV1,
+    DockerV2,
+    OCI,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ImageTypes, {
+    {ImageTypes::Invalid, "Invalid"},
+    {ImageTypes::DockerV1, "DockerV1"},
+    {ImageTypes::DockerV2, "DockerV2"},
+    {ImageTypes::OCI, "OCI"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/ethernet_interface.hpp b/redfish-core/include/generated/enums/ethernet_interface.hpp
index f69aba1d9a..4dcc3cec27 100644
--- a/redfish-core/include/generated/enums/ethernet_interface.hpp
+++ b/redfish-core/include/generated/enums/ethernet_interface.hpp
@@ -45,6 +45,14 @@ enum class TeamMode{
     AdaptiveLoadBalancing,
 };
 
+enum class RoutingScope{
+    Invalid,
+    External,
+    HostOnly,
+    Internal,
+    Limited,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(LinkStatus, {
     {LinkStatus::Invalid, "Invalid"},
     {LinkStatus::LinkUp, "LinkUp"},
@@ -85,5 +93,13 @@ NLOHMANN_JSON_SERIALIZE_ENUM(TeamMode, {
     {TeamMode::AdaptiveLoadBalancing, "AdaptiveLoadBalancing"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(RoutingScope, {
+    {RoutingScope::Invalid, "Invalid"},
+    {RoutingScope::External, "External"},
+    {RoutingScope::HostOnly, "HostOnly"},
+    {RoutingScope::Internal, "Internal"},
+    {RoutingScope::Limited, "Limited"},
+});
+
 }
 // clang-format on
diff --git a/redfish-core/include/generated/enums/log_service.hpp b/redfish-core/include/generated/enums/log_service.hpp
index 142bc96e8f..d7dcfc8f7c 100644
--- a/redfish-core/include/generated/enums/log_service.hpp
+++ b/redfish-core/include/generated/enums/log_service.hpp
@@ -18,6 +18,7 @@ enum class LogEntryTypes{
     SEL,
     Multiple,
     OEM,
+    CXL,
 };
 
 enum class SyslogSeverity{
@@ -92,6 +93,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(LogEntryTypes, {
     {LogEntryTypes::SEL, "SEL"},
     {LogEntryTypes::Multiple, "Multiple"},
     {LogEntryTypes::OEM, "OEM"},
+    {LogEntryTypes::CXL, "CXL"},
 });
 
 NLOHMANN_JSON_SERIALIZE_ENUM(SyslogSeverity, {
diff --git a/redfish-core/include/generated/enums/memory_region.hpp b/redfish-core/include/generated/enums/memory_region.hpp
new file mode 100644
index 0000000000..fa215e586b
--- /dev/null
+++ b/redfish-core/include/generated/enums/memory_region.hpp
@@ -0,0 +1,21 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace memory_region
+{
+// clang-format off
+
+enum class RegionType{
+    Invalid,
+    Static,
+    Dynamic,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(RegionType, {
+    {RegionType::Invalid, "Invalid"},
+    {RegionType::Static, "Static"},
+    {RegionType::Dynamic, "Dynamic"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/operating_system.hpp b/redfish-core/include/generated/enums/operating_system.hpp
new file mode 100644
index 0000000000..cbe3e0879c
--- /dev/null
+++ b/redfish-core/include/generated/enums/operating_system.hpp
@@ -0,0 +1,95 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace operating_system
+{
+// clang-format off
+
+enum class OperatingSystemTypes{
+    Invalid,
+    Linux,
+    Windows,
+    Solaris,
+    HPUX,
+    AIX,
+    BSD,
+    macOS,
+    IBMi,
+    Hypervisor,
+};
+
+enum class VirtualMachineEngineTypes{
+    Invalid,
+    VMwareESX,
+    HyperV,
+    Xen,
+    KVM,
+    QEMU,
+    VirtualBox,
+    PowerVM,
+};
+
+enum class VirtualMachineImageTypes{
+    Invalid,
+    Raw,
+    OVF,
+    OVA,
+    VHD,
+    VMDK,
+    VDI,
+    QCOW,
+    QCOW2,
+};
+
+enum class ContainerEngineTypes{
+    Invalid,
+    Docker,
+    containerd,
+    CRIO,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(OperatingSystemTypes, {
+    {OperatingSystemTypes::Invalid, "Invalid"},
+    {OperatingSystemTypes::Linux, "Linux"},
+    {OperatingSystemTypes::Windows, "Windows"},
+    {OperatingSystemTypes::Solaris, "Solaris"},
+    {OperatingSystemTypes::HPUX, "HPUX"},
+    {OperatingSystemTypes::AIX, "AIX"},
+    {OperatingSystemTypes::BSD, "BSD"},
+    {OperatingSystemTypes::macOS, "macOS"},
+    {OperatingSystemTypes::IBMi, "IBMi"},
+    {OperatingSystemTypes::Hypervisor, "Hypervisor"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(VirtualMachineEngineTypes, {
+    {VirtualMachineEngineTypes::Invalid, "Invalid"},
+    {VirtualMachineEngineTypes::VMwareESX, "VMwareESX"},
+    {VirtualMachineEngineTypes::HyperV, "HyperV"},
+    {VirtualMachineEngineTypes::Xen, "Xen"},
+    {VirtualMachineEngineTypes::KVM, "KVM"},
+    {VirtualMachineEngineTypes::QEMU, "QEMU"},
+    {VirtualMachineEngineTypes::VirtualBox, "VirtualBox"},
+    {VirtualMachineEngineTypes::PowerVM, "PowerVM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(VirtualMachineImageTypes, {
+    {VirtualMachineImageTypes::Invalid, "Invalid"},
+    {VirtualMachineImageTypes::Raw, "Raw"},
+    {VirtualMachineImageTypes::OVF, "OVF"},
+    {VirtualMachineImageTypes::OVA, "OVA"},
+    {VirtualMachineImageTypes::VHD, "VHD"},
+    {VirtualMachineImageTypes::VMDK, "VMDK"},
+    {VirtualMachineImageTypes::VDI, "VDI"},
+    {VirtualMachineImageTypes::QCOW, "QCOW"},
+    {VirtualMachineImageTypes::QCOW2, "QCOW2"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ContainerEngineTypes, {
+    {ContainerEngineTypes::Invalid, "Invalid"},
+    {ContainerEngineTypes::Docker, "Docker"},
+    {ContainerEngineTypes::containerd, "containerd"},
+    {ContainerEngineTypes::CRIO, "CRIO"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/outbound_connection.hpp b/redfish-core/include/generated/enums/outbound_connection.hpp
new file mode 100644
index 0000000000..d9cca9c33b
--- /dev/null
+++ b/redfish-core/include/generated/enums/outbound_connection.hpp
@@ -0,0 +1,39 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace outbound_connection
+{
+// clang-format off
+
+enum class OutboundConnectionRetryPolicyType{
+    Invalid,
+    None,
+    RetryForever,
+    RetryCount,
+};
+
+enum class AuthenticationType{
+    Invalid,
+    MTLS,
+    JWT,
+    None,
+    OEM,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(OutboundConnectionRetryPolicyType, {
+    {OutboundConnectionRetryPolicyType::Invalid, "Invalid"},
+    {OutboundConnectionRetryPolicyType::None, "None"},
+    {OutboundConnectionRetryPolicyType::RetryForever, "RetryForever"},
+    {OutboundConnectionRetryPolicyType::RetryCount, "RetryCount"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(AuthenticationType, {
+    {AuthenticationType::Invalid, "Invalid"},
+    {AuthenticationType::MTLS, "MTLS"},
+    {AuthenticationType::JWT, "JWT"},
+    {AuthenticationType::None, "None"},
+    {AuthenticationType::OEM, "OEM"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/pcie_device.hpp b/redfish-core/include/generated/enums/pcie_device.hpp
index c07e14b031..209d0030fe 100644
--- a/redfish-core/include/generated/enums/pcie_device.hpp
+++ b/redfish-core/include/generated/enums/pcie_device.hpp
@@ -49,6 +49,14 @@ enum class CXLDeviceType{
     Type3,
 };
 
+enum class CXLDynamicCapacityPolicies{
+    Invalid,
+    Free,
+    Contiguous,
+    Prescriptive,
+    TagBased,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(PCIeTypes, {
     {PCIeTypes::Invalid, "Invalid"},
     {PCIeTypes::Gen1, "Gen1"},
@@ -93,5 +101,13 @@ NLOHMANN_JSON_SERIALIZE_ENUM(CXLDeviceType, {
     {CXLDeviceType::Type3, "Type3"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(CXLDynamicCapacityPolicies, {
+    {CXLDynamicCapacityPolicies::Invalid, "Invalid"},
+    {CXLDynamicCapacityPolicies::Free, "Free"},
+    {CXLDynamicCapacityPolicies::Contiguous, "Contiguous"},
+    {CXLDynamicCapacityPolicies::Prescriptive, "Prescriptive"},
+    {CXLDynamicCapacityPolicies::TagBased, "TagBased"},
+});
+
 }
 // clang-format on
diff --git a/redfish-core/include/generated/enums/protocol.hpp b/redfish-core/include/generated/enums/protocol.hpp
index 55c0873053..7a613e3eec 100644
--- a/redfish-core/include/generated/enums/protocol.hpp
+++ b/redfish-core/include/generated/enums/protocol.hpp
@@ -45,6 +45,8 @@ enum class Protocol{
     VGA,
     DVI,
     CXL,
+    UPI,
+    QPI,
 };
 
 NLOHMANN_JSON_SERIALIZE_ENUM(Protocol, {
@@ -87,6 +89,8 @@ NLOHMANN_JSON_SERIALIZE_ENUM(Protocol, {
     {Protocol::VGA, "VGA"},
     {Protocol::DVI, "DVI"},
     {Protocol::CXL, "CXL"},
+    {Protocol::UPI, "UPI"},
+    {Protocol::QPI, "QPI"},
 });
 
 }
diff --git a/redfish-core/include/generated/enums/session.hpp b/redfish-core/include/generated/enums/session.hpp
index 61da667912..99958a880d 100644
--- a/redfish-core/include/generated/enums/session.hpp
+++ b/redfish-core/include/generated/enums/session.hpp
@@ -15,6 +15,7 @@ enum class SessionTypes{
     Redfish,
     VirtualMedia,
     WebUI,
+    OutboundConnection,
 };
 
 NLOHMANN_JSON_SERIALIZE_ENUM(SessionTypes, {
@@ -27,6 +28,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(SessionTypes, {
     {SessionTypes::Redfish, "Redfish"},
     {SessionTypes::VirtualMedia, "VirtualMedia"},
     {SessionTypes::WebUI, "WebUI"},
+    {SessionTypes::OutboundConnection, "OutboundConnection"},
 });
 
 }
diff --git a/redfish-core/include/generated/enums/software_inventory.hpp b/redfish-core/include/generated/enums/software_inventory.hpp
index b580050eed..2c2688d306 100644
--- a/redfish-core/include/generated/enums/software_inventory.hpp
+++ b/redfish-core/include/generated/enums/software_inventory.hpp
@@ -12,6 +12,13 @@ enum class VersionScheme{
     OEM,
 };
 
+enum class ReleaseType{
+    Invalid,
+    Production,
+    Prototype,
+    Other,
+};
+
 NLOHMANN_JSON_SERIALIZE_ENUM(VersionScheme, {
     {VersionScheme::Invalid, "Invalid"},
     {VersionScheme::SemVer, "SemVer"},
@@ -19,5 +26,12 @@ NLOHMANN_JSON_SERIALIZE_ENUM(VersionScheme, {
     {VersionScheme::OEM, "OEM"},
 });
 
+NLOHMANN_JSON_SERIALIZE_ENUM(ReleaseType, {
+    {ReleaseType::Invalid, "Invalid"},
+    {ReleaseType::Production, "Production"},
+    {ReleaseType::Prototype, "Prototype"},
+    {ReleaseType::Other, "Other"},
+});
+
 }
 // clang-format on
diff --git a/redfish-core/include/generated/enums/volume.hpp b/redfish-core/include/generated/enums/volume.hpp
index f9e323b9a2..516ea83501 100644
--- a/redfish-core/include/generated/enums/volume.hpp
+++ b/redfish-core/include/generated/enums/volume.hpp
@@ -138,6 +138,7 @@ enum class OperationType{
     Compress,
     Sanitize,
     Format,
+    ChangeStripSize,
 };
 
 enum class LBARelativePerformanceType{
@@ -281,6 +282,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(OperationType, {
     {OperationType::Compress, "Compress"},
     {OperationType::Sanitize, "Sanitize"},
     {OperationType::Format, "Format"},
+    {OperationType::ChangeStripSize, "ChangeStripSize"},
 });
 
 NLOHMANN_JSON_SERIALIZE_ENUM(LBARelativePerformanceType, {