diff --git a/.clang-tidy b/.clang-tidy
index bed3fad..8af0822 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -315,3 +315,4 @@
   - { key: readability-identifier-naming.ParameterCase, value: camelBack }
   - { key: readability-identifier-naming.NamespaceCase, value: lower_case }
   - { key: readability-identifier-naming.StructCase,    value: CamelCase  }
+  - { key: cppcoreguidelines-macro-usage.AllowedRegexp, value: DEBUG*|NLOHMANN_JSON_SERIALIZE_ENUM }
diff --git a/redfish-core/include/generated/enums/account_service.hpp b/redfish-core/include/generated/enums/account_service.hpp
new file mode 100644
index 0000000..169b5f9
--- /dev/null
+++ b/redfish-core/include/generated/enums/account_service.hpp
@@ -0,0 +1,91 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace account_service
+{
+// clang-format off
+
+enum class LocalAccountAuth{
+    Invalid,
+    Enabled,
+    Disabled,
+    Fallback,
+    LocalFirst,
+};
+
+enum class AccountProviderTypes{
+    Invalid,
+    RedfishService,
+    ActiveDirectoryService,
+    LDAPService,
+    OEM,
+    TACACSplus,
+    OAuth2,
+};
+
+enum class AuthenticationTypes{
+    Invalid,
+    Token,
+    KerberosKeytab,
+    UsernameAndPassword,
+    OEM,
+};
+
+enum class TACACSplusPasswordExchangeProtocol{
+    Invalid,
+    ASCII,
+    PAP,
+    CHAP,
+    MSCHAPv1,
+    MSCHAPv2,
+};
+
+enum class OAuth2Mode{
+    Invalid,
+    Discovery,
+    Offline,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(LocalAccountAuth, {
+    {LocalAccountAuth::Invalid, "Invalid"},
+    {LocalAccountAuth::Enabled, "Enabled"},
+    {LocalAccountAuth::Disabled, "Disabled"},
+    {LocalAccountAuth::Fallback, "Fallback"},
+    {LocalAccountAuth::LocalFirst, "LocalFirst"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(AccountProviderTypes, {
+    {AccountProviderTypes::Invalid, "Invalid"},
+    {AccountProviderTypes::RedfishService, "RedfishService"},
+    {AccountProviderTypes::ActiveDirectoryService, "ActiveDirectoryService"},
+    {AccountProviderTypes::LDAPService, "LDAPService"},
+    {AccountProviderTypes::OEM, "OEM"},
+    {AccountProviderTypes::TACACSplus, "TACACSplus"},
+    {AccountProviderTypes::OAuth2, "OAuth2"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(AuthenticationTypes, {
+    {AuthenticationTypes::Invalid, "Invalid"},
+    {AuthenticationTypes::Token, "Token"},
+    {AuthenticationTypes::KerberosKeytab, "KerberosKeytab"},
+    {AuthenticationTypes::UsernameAndPassword, "UsernameAndPassword"},
+    {AuthenticationTypes::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(TACACSplusPasswordExchangeProtocol, {
+    {TACACSplusPasswordExchangeProtocol::Invalid, "Invalid"},
+    {TACACSplusPasswordExchangeProtocol::ASCII, "ASCII"},
+    {TACACSplusPasswordExchangeProtocol::PAP, "PAP"},
+    {TACACSplusPasswordExchangeProtocol::CHAP, "CHAP"},
+    {TACACSplusPasswordExchangeProtocol::MSCHAPv1, "MSCHAPv1"},
+    {TACACSplusPasswordExchangeProtocol::MSCHAPv2, "MSCHAPv2"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(OAuth2Mode, {
+    {OAuth2Mode::Invalid, "Invalid"},
+    {OAuth2Mode::Discovery, "Discovery"},
+    {OAuth2Mode::Offline, "Offline"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/action_info.hpp b/redfish-core/include/generated/enums/action_info.hpp
new file mode 100644
index 0000000..4934abc
--- /dev/null
+++ b/redfish-core/include/generated/enums/action_info.hpp
@@ -0,0 +1,31 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace action_info
+{
+// clang-format off
+
+enum class ParameterTypes{
+    Invalid,
+    Boolean,
+    Number,
+    NumberArray,
+    String,
+    StringArray,
+    Object,
+    ObjectArray,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ParameterTypes, {
+    {ParameterTypes::Invalid, "Invalid"},
+    {ParameterTypes::Boolean, "Boolean"},
+    {ParameterTypes::Number, "Number"},
+    {ParameterTypes::NumberArray, "NumberArray"},
+    {ParameterTypes::String, "String"},
+    {ParameterTypes::StringArray, "StringArray"},
+    {ParameterTypes::Object, "Object"},
+    {ParameterTypes::ObjectArray, "ObjectArray"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/attribute_registry.hpp b/redfish-core/include/generated/enums/attribute_registry.hpp
new file mode 100644
index 0000000..b24a788
--- /dev/null
+++ b/redfish-core/include/generated/enums/attribute_registry.hpp
@@ -0,0 +1,141 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace attribute_registry
+{
+// clang-format off
+
+enum class AttributeType{
+    Invalid,
+    Enumeration,
+    String,
+    Integer,
+    Boolean,
+    Password,
+};
+
+enum class DependencyType{
+    Invalid,
+    Map,
+};
+
+enum class MapFromCondition{
+    Invalid,
+    EQU,
+    NEQ,
+    GTR,
+    GEQ,
+    LSS,
+    LEQ,
+};
+
+enum class MapFromProperty{
+    Invalid,
+    CurrentValue,
+    DefaultValue,
+    ReadOnly,
+    WriteOnly,
+    GrayOut,
+    Hidden,
+    LowerBound,
+    UpperBound,
+    MinLength,
+    MaxLength,
+    ScalarIncrement,
+};
+
+enum class MapTerms{
+    Invalid,
+    AND,
+    OR,
+};
+
+enum class MapToProperty{
+    Invalid,
+    CurrentValue,
+    DefaultValue,
+    ReadOnly,
+    WriteOnly,
+    GrayOut,
+    Hidden,
+    Immutable,
+    HelpText,
+    WarningText,
+    DisplayName,
+    DisplayOrder,
+    LowerBound,
+    UpperBound,
+    MinLength,
+    MaxLength,
+    ScalarIncrement,
+    ValueExpression,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(AttributeType, {
+    {AttributeType::Invalid, "Invalid"},
+    {AttributeType::Enumeration, "Enumeration"},
+    {AttributeType::String, "String"},
+    {AttributeType::Integer, "Integer"},
+    {AttributeType::Boolean, "Boolean"},
+    {AttributeType::Password, "Password"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(DependencyType, {
+    {DependencyType::Invalid, "Invalid"},
+    {DependencyType::Map, "Map"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MapFromCondition, {
+    {MapFromCondition::Invalid, "Invalid"},
+    {MapFromCondition::EQU, "EQU"},
+    {MapFromCondition::NEQ, "NEQ"},
+    {MapFromCondition::GTR, "GTR"},
+    {MapFromCondition::GEQ, "GEQ"},
+    {MapFromCondition::LSS, "LSS"},
+    {MapFromCondition::LEQ, "LEQ"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MapFromProperty, {
+    {MapFromProperty::Invalid, "Invalid"},
+    {MapFromProperty::CurrentValue, "CurrentValue"},
+    {MapFromProperty::DefaultValue, "DefaultValue"},
+    {MapFromProperty::ReadOnly, "ReadOnly"},
+    {MapFromProperty::WriteOnly, "WriteOnly"},
+    {MapFromProperty::GrayOut, "GrayOut"},
+    {MapFromProperty::Hidden, "Hidden"},
+    {MapFromProperty::LowerBound, "LowerBound"},
+    {MapFromProperty::UpperBound, "UpperBound"},
+    {MapFromProperty::MinLength, "MinLength"},
+    {MapFromProperty::MaxLength, "MaxLength"},
+    {MapFromProperty::ScalarIncrement, "ScalarIncrement"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MapTerms, {
+    {MapTerms::Invalid, "Invalid"},
+    {MapTerms::AND, "AND"},
+    {MapTerms::OR, "OR"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MapToProperty, {
+    {MapToProperty::Invalid, "Invalid"},
+    {MapToProperty::CurrentValue, "CurrentValue"},
+    {MapToProperty::DefaultValue, "DefaultValue"},
+    {MapToProperty::ReadOnly, "ReadOnly"},
+    {MapToProperty::WriteOnly, "WriteOnly"},
+    {MapToProperty::GrayOut, "GrayOut"},
+    {MapToProperty::Hidden, "Hidden"},
+    {MapToProperty::Immutable, "Immutable"},
+    {MapToProperty::HelpText, "HelpText"},
+    {MapToProperty::WarningText, "WarningText"},
+    {MapToProperty::DisplayName, "DisplayName"},
+    {MapToProperty::DisplayOrder, "DisplayOrder"},
+    {MapToProperty::LowerBound, "LowerBound"},
+    {MapToProperty::UpperBound, "UpperBound"},
+    {MapToProperty::MinLength, "MinLength"},
+    {MapToProperty::MaxLength, "MaxLength"},
+    {MapToProperty::ScalarIncrement, "ScalarIncrement"},
+    {MapToProperty::ValueExpression, "ValueExpression"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/cable.hpp b/redfish-core/include/generated/enums/cable.hpp
new file mode 100644
index 0000000..1d316b9
--- /dev/null
+++ b/redfish-core/include/generated/enums/cable.hpp
@@ -0,0 +1,105 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace cable
+{
+// clang-format off
+
+enum class CableClass{
+    Invalid,
+    Power,
+    Network,
+    Storage,
+    Fan,
+    PCIe,
+    USB,
+    Video,
+    Fabric,
+    Serial,
+    General,
+};
+
+enum class ConnectorType{
+    Invalid,
+    ACPower,
+    DB9,
+    DCPower,
+    DisplayPort,
+    HDMI,
+    ICI,
+    IPASS,
+    PCIe,
+    Proprietary,
+    RJ45,
+    SATA,
+    SCSI,
+    SlimSAS,
+    SFP,
+    SFPPlus,
+    USBA,
+    USBC,
+    QSFP,
+    CDFP,
+    OSFP,
+};
+
+enum class CableStatus{
+    Invalid,
+    Normal,
+    Degraded,
+    Failed,
+    Testing,
+    Disabled,
+    SetByService,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(CableClass, {
+    {CableClass::Invalid, "Invalid"},
+    {CableClass::Power, "Power"},
+    {CableClass::Network, "Network"},
+    {CableClass::Storage, "Storage"},
+    {CableClass::Fan, "Fan"},
+    {CableClass::PCIe, "PCIe"},
+    {CableClass::USB, "USB"},
+    {CableClass::Video, "Video"},
+    {CableClass::Fabric, "Fabric"},
+    {CableClass::Serial, "Serial"},
+    {CableClass::General, "General"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ConnectorType, {
+    {ConnectorType::Invalid, "Invalid"},
+    {ConnectorType::ACPower, "ACPower"},
+    {ConnectorType::DB9, "DB9"},
+    {ConnectorType::DCPower, "DCPower"},
+    {ConnectorType::DisplayPort, "DisplayPort"},
+    {ConnectorType::HDMI, "HDMI"},
+    {ConnectorType::ICI, "ICI"},
+    {ConnectorType::IPASS, "IPASS"},
+    {ConnectorType::PCIe, "PCIe"},
+    {ConnectorType::Proprietary, "Proprietary"},
+    {ConnectorType::RJ45, "RJ45"},
+    {ConnectorType::SATA, "SATA"},
+    {ConnectorType::SCSI, "SCSI"},
+    {ConnectorType::SlimSAS, "SlimSAS"},
+    {ConnectorType::SFP, "SFP"},
+    {ConnectorType::SFPPlus, "SFPPlus"},
+    {ConnectorType::USBA, "USBA"},
+    {ConnectorType::USBC, "USBC"},
+    {ConnectorType::QSFP, "QSFP"},
+    {ConnectorType::CDFP, "CDFP"},
+    {ConnectorType::OSFP, "OSFP"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(CableStatus, {
+    {CableStatus::Invalid, "Invalid"},
+    {CableStatus::Normal, "Normal"},
+    {CableStatus::Degraded, "Degraded"},
+    {CableStatus::Failed, "Failed"},
+    {CableStatus::Testing, "Testing"},
+    {CableStatus::Disabled, "Disabled"},
+    {CableStatus::SetByService, "SetByService"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/certificate.hpp b/redfish-core/include/generated/enums/certificate.hpp
new file mode 100644
index 0000000..8603197
--- /dev/null
+++ b/redfish-core/include/generated/enums/certificate.hpp
@@ -0,0 +1,81 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace certificate
+{
+// clang-format off
+
+enum class CertificateType{
+    Invalid,
+    PEM,
+    PEMchain,
+    PKCS7,
+};
+
+enum class KeyUsage{
+    Invalid,
+    DigitalSignature,
+    NonRepudiation,
+    KeyEncipherment,
+    DataEncipherment,
+    KeyAgreement,
+    KeyCertSign,
+    CRLSigning,
+    EncipherOnly,
+    DecipherOnly,
+    ServerAuthentication,
+    ClientAuthentication,
+    CodeSigning,
+    EmailProtection,
+    Timestamping,
+    OCSPSigning,
+};
+
+enum class CertificateUsageType{
+    Invalid,
+    User,
+    Web,
+    SSH,
+    Device,
+    Platform,
+    BIOS,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(CertificateType, {
+    {CertificateType::Invalid, "Invalid"},
+    {CertificateType::PEM, "PEM"},
+    {CertificateType::PEMchain, "PEMchain"},
+    {CertificateType::PKCS7, "PKCS7"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(KeyUsage, {
+    {KeyUsage::Invalid, "Invalid"},
+    {KeyUsage::DigitalSignature, "DigitalSignature"},
+    {KeyUsage::NonRepudiation, "NonRepudiation"},
+    {KeyUsage::KeyEncipherment, "KeyEncipherment"},
+    {KeyUsage::DataEncipherment, "DataEncipherment"},
+    {KeyUsage::KeyAgreement, "KeyAgreement"},
+    {KeyUsage::KeyCertSign, "KeyCertSign"},
+    {KeyUsage::CRLSigning, "CRLSigning"},
+    {KeyUsage::EncipherOnly, "EncipherOnly"},
+    {KeyUsage::DecipherOnly, "DecipherOnly"},
+    {KeyUsage::ServerAuthentication, "ServerAuthentication"},
+    {KeyUsage::ClientAuthentication, "ClientAuthentication"},
+    {KeyUsage::CodeSigning, "CodeSigning"},
+    {KeyUsage::EmailProtection, "EmailProtection"},
+    {KeyUsage::Timestamping, "Timestamping"},
+    {KeyUsage::OCSPSigning, "OCSPSigning"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(CertificateUsageType, {
+    {CertificateUsageType::Invalid, "Invalid"},
+    {CertificateUsageType::User, "User"},
+    {CertificateUsageType::Web, "Web"},
+    {CertificateUsageType::SSH, "SSH"},
+    {CertificateUsageType::Device, "Device"},
+    {CertificateUsageType::Platform, "Platform"},
+    {CertificateUsageType::BIOS, "BIOS"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/chassis.hpp b/redfish-core/include/generated/enums/chassis.hpp
new file mode 100644
index 0000000..5628624
--- /dev/null
+++ b/redfish-core/include/generated/enums/chassis.hpp
@@ -0,0 +1,149 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace chassis
+{
+// clang-format off
+
+enum class ChassisType{
+    Invalid,
+    Rack,
+    Blade,
+    Enclosure,
+    StandAlone,
+    RackMount,
+    Card,
+    Cartridge,
+    Row,
+    Pod,
+    Expansion,
+    Sidecar,
+    Zone,
+    Sled,
+    Shelf,
+    Drawer,
+    Module,
+    Component,
+    IPBasedDrive,
+    RackGroup,
+    StorageEnclosure,
+    Other,
+};
+
+enum class IndicatorLED{
+    Invalid,
+    Unknown,
+    Lit,
+    Blinking,
+    Off,
+};
+
+enum class PowerState{
+    Invalid,
+    On,
+    Off,
+    PoweringOn,
+    PoweringOff,
+};
+
+enum class IntrusionSensor{
+    Invalid,
+    Normal,
+    HardwareIntrusion,
+    TamperingDetected,
+};
+
+enum class IntrusionSensorReArm{
+    Invalid,
+    Manual,
+    Automatic,
+};
+
+enum class EnvironmentalClass{
+    Invalid,
+    A1,
+    A2,
+    A3,
+    A4,
+};
+
+enum class ThermalDirection{
+    Invalid,
+    FrontToBack,
+    BackToFront,
+    TopExhaust,
+    Sealed,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ChassisType, {
+    {ChassisType::Invalid, "Invalid"},
+    {ChassisType::Rack, "Rack"},
+    {ChassisType::Blade, "Blade"},
+    {ChassisType::Enclosure, "Enclosure"},
+    {ChassisType::StandAlone, "StandAlone"},
+    {ChassisType::RackMount, "RackMount"},
+    {ChassisType::Card, "Card"},
+    {ChassisType::Cartridge, "Cartridge"},
+    {ChassisType::Row, "Row"},
+    {ChassisType::Pod, "Pod"},
+    {ChassisType::Expansion, "Expansion"},
+    {ChassisType::Sidecar, "Sidecar"},
+    {ChassisType::Zone, "Zone"},
+    {ChassisType::Sled, "Sled"},
+    {ChassisType::Shelf, "Shelf"},
+    {ChassisType::Drawer, "Drawer"},
+    {ChassisType::Module, "Module"},
+    {ChassisType::Component, "Component"},
+    {ChassisType::IPBasedDrive, "IPBasedDrive"},
+    {ChassisType::RackGroup, "RackGroup"},
+    {ChassisType::StorageEnclosure, "StorageEnclosure"},
+    {ChassisType::Other, "Other"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(IndicatorLED, {
+    {IndicatorLED::Invalid, "Invalid"},
+    {IndicatorLED::Unknown, "Unknown"},
+    {IndicatorLED::Lit, "Lit"},
+    {IndicatorLED::Blinking, "Blinking"},
+    {IndicatorLED::Off, "Off"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PowerState, {
+    {PowerState::Invalid, "Invalid"},
+    {PowerState::On, "On"},
+    {PowerState::Off, "Off"},
+    {PowerState::PoweringOn, "PoweringOn"},
+    {PowerState::PoweringOff, "PoweringOff"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(IntrusionSensor, {
+    {IntrusionSensor::Invalid, "Invalid"},
+    {IntrusionSensor::Normal, "Normal"},
+    {IntrusionSensor::HardwareIntrusion, "HardwareIntrusion"},
+    {IntrusionSensor::TamperingDetected, "TamperingDetected"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(IntrusionSensorReArm, {
+    {IntrusionSensorReArm::Invalid, "Invalid"},
+    {IntrusionSensorReArm::Manual, "Manual"},
+    {IntrusionSensorReArm::Automatic, "Automatic"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(EnvironmentalClass, {
+    {EnvironmentalClass::Invalid, "Invalid"},
+    {EnvironmentalClass::A1, "A1"},
+    {EnvironmentalClass::A2, "A2"},
+    {EnvironmentalClass::A3, "A3"},
+    {EnvironmentalClass::A4, "A4"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ThermalDirection, {
+    {ThermalDirection::Invalid, "Invalid"},
+    {ThermalDirection::FrontToBack, "FrontToBack"},
+    {ThermalDirection::BackToFront, "BackToFront"},
+    {ThermalDirection::TopExhaust, "TopExhaust"},
+    {ThermalDirection::Sealed, "Sealed"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/computer_system.hpp b/redfish-core/include/generated/enums/computer_system.hpp
new file mode 100644
index 0000000..2545a22
--- /dev/null
+++ b/redfish-core/include/generated/enums/computer_system.hpp
@@ -0,0 +1,373 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace computer_system
+{
+// clang-format off
+
+enum class BootSource{
+    Invalid,
+    None,
+    Pxe,
+    Floppy,
+    Cd,
+    Usb,
+    Hdd,
+    BiosSetup,
+    Utilities,
+    Diags,
+    UefiShell,
+    UefiTarget,
+    SDCard,
+    UefiHttp,
+    RemoteDrive,
+    UefiBootNext,
+    Recovery,
+};
+
+enum class SystemType{
+    Invalid,
+    Physical,
+    Virtual,
+    OS,
+    PhysicallyPartitioned,
+    VirtuallyPartitioned,
+    Composed,
+    DPU,
+};
+
+enum class IndicatorLED{
+    Invalid,
+    Unknown,
+    Lit,
+    Blinking,
+    Off,
+};
+
+enum class PowerState{
+    Invalid,
+    On,
+    Off,
+    PoweringOn,
+    PoweringOff,
+};
+
+enum class BootSourceOverrideEnabled{
+    Invalid,
+    Disabled,
+    Once,
+    Continuous,
+};
+
+enum class MemoryMirroring{
+    Invalid,
+    System,
+    DIMM,
+    Hybrid,
+    None,
+};
+
+enum class BootSourceOverrideMode{
+    Invalid,
+    Legacy,
+    UEFI,
+};
+
+enum class InterfaceType{
+    Invalid,
+    TPM1_2,
+    TPM2_0,
+    TCM1_0,
+};
+
+enum class HostingRole{
+    Invalid,
+    ApplicationServer,
+    StorageServer,
+    Switch,
+    Appliance,
+    BareMetalServer,
+    VirtualMachineServer,
+    ContainerServer,
+};
+
+enum class InterfaceTypeSelection{
+    Invalid,
+    None,
+    FirmwareUpdate,
+    BiosSetting,
+    OemMethod,
+};
+
+enum class WatchdogWarningActions{
+    Invalid,
+    None,
+    DiagnosticInterrupt,
+    SMI,
+    MessagingInterrupt,
+    SCI,
+    OEM,
+};
+
+enum class WatchdogTimeoutActions{
+    Invalid,
+    None,
+    ResetSystem,
+    PowerCycle,
+    PowerDown,
+    OEM,
+};
+
+enum class PowerRestorePolicyTypes{
+    Invalid,
+    AlwaysOn,
+    AlwaysOff,
+    LastState,
+};
+
+enum class BootOrderTypes{
+    Invalid,
+    BootOrder,
+    AliasBootOrder,
+};
+
+enum class AutomaticRetryConfig{
+    Invalid,
+    Disabled,
+    RetryAttempts,
+    RetryAlways,
+};
+
+enum class BootProgressTypes{
+    Invalid,
+    None,
+    PrimaryProcessorInitializationStarted,
+    BusInitializationStarted,
+    MemoryInitializationStarted,
+    SecondaryProcessorInitializationStarted,
+    PCIResourceConfigStarted,
+    SystemHardwareInitializationComplete,
+    SetupEntered,
+    OSBootStarted,
+    OSRunning,
+    OEM,
+};
+
+enum class GraphicalConnectTypesSupported{
+    Invalid,
+    KVMIP,
+    OEM,
+};
+
+enum class TrustedModuleRequiredToBoot{
+    Invalid,
+    Disabled,
+    Required,
+};
+
+enum class StopBootOnFault{
+    Invalid,
+    Never,
+    AnyFault,
+};
+
+enum class PowerMode{
+    Invalid,
+    MaximumPerformance,
+    BalancedPerformance,
+    PowerSaving,
+    Static,
+    OSControlled,
+    OEM,
+};
+
+enum class CompositionUseCase{
+    Invalid,
+    ResourceBlockCapable,
+    ExpandableSystem,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(BootSource, {
+    {BootSource::Invalid, "Invalid"},
+    {BootSource::None, "None"},
+    {BootSource::Pxe, "Pxe"},
+    {BootSource::Floppy, "Floppy"},
+    {BootSource::Cd, "Cd"},
+    {BootSource::Usb, "Usb"},
+    {BootSource::Hdd, "Hdd"},
+    {BootSource::BiosSetup, "BiosSetup"},
+    {BootSource::Utilities, "Utilities"},
+    {BootSource::Diags, "Diags"},
+    {BootSource::UefiShell, "UefiShell"},
+    {BootSource::UefiTarget, "UefiTarget"},
+    {BootSource::SDCard, "SDCard"},
+    {BootSource::UefiHttp, "UefiHttp"},
+    {BootSource::RemoteDrive, "RemoteDrive"},
+    {BootSource::UefiBootNext, "UefiBootNext"},
+    {BootSource::Recovery, "Recovery"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SystemType, {
+    {SystemType::Invalid, "Invalid"},
+    {SystemType::Physical, "Physical"},
+    {SystemType::Virtual, "Virtual"},
+    {SystemType::OS, "OS"},
+    {SystemType::PhysicallyPartitioned, "PhysicallyPartitioned"},
+    {SystemType::VirtuallyPartitioned, "VirtuallyPartitioned"},
+    {SystemType::Composed, "Composed"},
+    {SystemType::DPU, "DPU"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(IndicatorLED, {
+    {IndicatorLED::Invalid, "Invalid"},
+    {IndicatorLED::Unknown, "Unknown"},
+    {IndicatorLED::Lit, "Lit"},
+    {IndicatorLED::Blinking, "Blinking"},
+    {IndicatorLED::Off, "Off"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PowerState, {
+    {PowerState::Invalid, "Invalid"},
+    {PowerState::On, "On"},
+    {PowerState::Off, "Off"},
+    {PowerState::PoweringOn, "PoweringOn"},
+    {PowerState::PoweringOff, "PoweringOff"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(BootSourceOverrideEnabled, {
+    {BootSourceOverrideEnabled::Invalid, "Invalid"},
+    {BootSourceOverrideEnabled::Disabled, "Disabled"},
+    {BootSourceOverrideEnabled::Once, "Once"},
+    {BootSourceOverrideEnabled::Continuous, "Continuous"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MemoryMirroring, {
+    {MemoryMirroring::Invalid, "Invalid"},
+    {MemoryMirroring::System, "System"},
+    {MemoryMirroring::DIMM, "DIMM"},
+    {MemoryMirroring::Hybrid, "Hybrid"},
+    {MemoryMirroring::None, "None"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(BootSourceOverrideMode, {
+    {BootSourceOverrideMode::Invalid, "Invalid"},
+    {BootSourceOverrideMode::Legacy, "Legacy"},
+    {BootSourceOverrideMode::UEFI, "UEFI"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(InterfaceType, {
+    {InterfaceType::Invalid, "Invalid"},
+    {InterfaceType::TPM1_2, "TPM1_2"},
+    {InterfaceType::TPM2_0, "TPM2_0"},
+    {InterfaceType::TCM1_0, "TCM1_0"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(HostingRole, {
+    {HostingRole::Invalid, "Invalid"},
+    {HostingRole::ApplicationServer, "ApplicationServer"},
+    {HostingRole::StorageServer, "StorageServer"},
+    {HostingRole::Switch, "Switch"},
+    {HostingRole::Appliance, "Appliance"},
+    {HostingRole::BareMetalServer, "BareMetalServer"},
+    {HostingRole::VirtualMachineServer, "VirtualMachineServer"},
+    {HostingRole::ContainerServer, "ContainerServer"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(InterfaceTypeSelection, {
+    {InterfaceTypeSelection::Invalid, "Invalid"},
+    {InterfaceTypeSelection::None, "None"},
+    {InterfaceTypeSelection::FirmwareUpdate, "FirmwareUpdate"},
+    {InterfaceTypeSelection::BiosSetting, "BiosSetting"},
+    {InterfaceTypeSelection::OemMethod, "OemMethod"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(WatchdogWarningActions, {
+    {WatchdogWarningActions::Invalid, "Invalid"},
+    {WatchdogWarningActions::None, "None"},
+    {WatchdogWarningActions::DiagnosticInterrupt, "DiagnosticInterrupt"},
+    {WatchdogWarningActions::SMI, "SMI"},
+    {WatchdogWarningActions::MessagingInterrupt, "MessagingInterrupt"},
+    {WatchdogWarningActions::SCI, "SCI"},
+    {WatchdogWarningActions::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(WatchdogTimeoutActions, {
+    {WatchdogTimeoutActions::Invalid, "Invalid"},
+    {WatchdogTimeoutActions::None, "None"},
+    {WatchdogTimeoutActions::ResetSystem, "ResetSystem"},
+    {WatchdogTimeoutActions::PowerCycle, "PowerCycle"},
+    {WatchdogTimeoutActions::PowerDown, "PowerDown"},
+    {WatchdogTimeoutActions::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PowerRestorePolicyTypes, {
+    {PowerRestorePolicyTypes::Invalid, "Invalid"},
+    {PowerRestorePolicyTypes::AlwaysOn, "AlwaysOn"},
+    {PowerRestorePolicyTypes::AlwaysOff, "AlwaysOff"},
+    {PowerRestorePolicyTypes::LastState, "LastState"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(BootOrderTypes, {
+    {BootOrderTypes::Invalid, "Invalid"},
+    {BootOrderTypes::BootOrder, "BootOrder"},
+    {BootOrderTypes::AliasBootOrder, "AliasBootOrder"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(AutomaticRetryConfig, {
+    {AutomaticRetryConfig::Invalid, "Invalid"},
+    {AutomaticRetryConfig::Disabled, "Disabled"},
+    {AutomaticRetryConfig::RetryAttempts, "RetryAttempts"},
+    {AutomaticRetryConfig::RetryAlways, "RetryAlways"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(BootProgressTypes, {
+    {BootProgressTypes::Invalid, "Invalid"},
+    {BootProgressTypes::None, "None"},
+    {BootProgressTypes::PrimaryProcessorInitializationStarted, "PrimaryProcessorInitializationStarted"},
+    {BootProgressTypes::BusInitializationStarted, "BusInitializationStarted"},
+    {BootProgressTypes::MemoryInitializationStarted, "MemoryInitializationStarted"},
+    {BootProgressTypes::SecondaryProcessorInitializationStarted, "SecondaryProcessorInitializationStarted"},
+    {BootProgressTypes::PCIResourceConfigStarted, "PCIResourceConfigStarted"},
+    {BootProgressTypes::SystemHardwareInitializationComplete, "SystemHardwareInitializationComplete"},
+    {BootProgressTypes::SetupEntered, "SetupEntered"},
+    {BootProgressTypes::OSBootStarted, "OSBootStarted"},
+    {BootProgressTypes::OSRunning, "OSRunning"},
+    {BootProgressTypes::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(GraphicalConnectTypesSupported, {
+    {GraphicalConnectTypesSupported::Invalid, "Invalid"},
+    {GraphicalConnectTypesSupported::KVMIP, "KVMIP"},
+    {GraphicalConnectTypesSupported::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(TrustedModuleRequiredToBoot, {
+    {TrustedModuleRequiredToBoot::Invalid, "Invalid"},
+    {TrustedModuleRequiredToBoot::Disabled, "Disabled"},
+    {TrustedModuleRequiredToBoot::Required, "Required"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(StopBootOnFault, {
+    {StopBootOnFault::Invalid, "Invalid"},
+    {StopBootOnFault::Never, "Never"},
+    {StopBootOnFault::AnyFault, "AnyFault"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PowerMode, {
+    {PowerMode::Invalid, "Invalid"},
+    {PowerMode::MaximumPerformance, "MaximumPerformance"},
+    {PowerMode::BalancedPerformance, "BalancedPerformance"},
+    {PowerMode::PowerSaving, "PowerSaving"},
+    {PowerMode::Static, "Static"},
+    {PowerMode::OSControlled, "OSControlled"},
+    {PowerMode::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(CompositionUseCase, {
+    {CompositionUseCase::Invalid, "Invalid"},
+    {CompositionUseCase::ResourceBlockCapable, "ResourceBlockCapable"},
+    {CompositionUseCase::ExpandableSystem, "ExpandableSystem"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/drive.hpp b/redfish-core/include/generated/enums/drive.hpp
new file mode 100644
index 0000000..c0eb2f0
--- /dev/null
+++ b/redfish-core/include/generated/enums/drive.hpp
@@ -0,0 +1,119 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace drive
+{
+// clang-format off
+
+enum class MediaType{
+    Invalid,
+    HDD,
+    SSD,
+    SMR,
+};
+
+enum class HotspareType{
+    Invalid,
+    None,
+    Global,
+    Chassis,
+    Dedicated,
+};
+
+enum class EncryptionAbility{
+    Invalid,
+    None,
+    SelfEncryptingDrive,
+    Other,
+};
+
+enum class EncryptionStatus{
+    Invalid,
+    Unecrypted,
+    Unlocked,
+    Locked,
+    Foreign,
+    Unencrypted,
+};
+
+enum class StatusIndicator{
+    Invalid,
+    OK,
+    Fail,
+    Rebuild,
+    PredictiveFailureAnalysis,
+    Hotspare,
+    InACriticalArray,
+    InAFailedArray,
+};
+
+enum class HotspareReplacementModeType{
+    Invalid,
+    Revertible,
+    NonRevertible,
+};
+
+enum class DataSanitizationType{
+    Invalid,
+    BlockErase,
+    CryptographicErase,
+    Overwrite,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MediaType, {
+    {MediaType::Invalid, "Invalid"},
+    {MediaType::HDD, "HDD"},
+    {MediaType::SSD, "SSD"},
+    {MediaType::SMR, "SMR"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(HotspareType, {
+    {HotspareType::Invalid, "Invalid"},
+    {HotspareType::None, "None"},
+    {HotspareType::Global, "Global"},
+    {HotspareType::Chassis, "Chassis"},
+    {HotspareType::Dedicated, "Dedicated"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(EncryptionAbility, {
+    {EncryptionAbility::Invalid, "Invalid"},
+    {EncryptionAbility::None, "None"},
+    {EncryptionAbility::SelfEncryptingDrive, "SelfEncryptingDrive"},
+    {EncryptionAbility::Other, "Other"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(EncryptionStatus, {
+    {EncryptionStatus::Invalid, "Invalid"},
+    {EncryptionStatus::Unecrypted, "Unecrypted"},
+    {EncryptionStatus::Unlocked, "Unlocked"},
+    {EncryptionStatus::Locked, "Locked"},
+    {EncryptionStatus::Foreign, "Foreign"},
+    {EncryptionStatus::Unencrypted, "Unencrypted"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(StatusIndicator, {
+    {StatusIndicator::Invalid, "Invalid"},
+    {StatusIndicator::OK, "OK"},
+    {StatusIndicator::Fail, "Fail"},
+    {StatusIndicator::Rebuild, "Rebuild"},
+    {StatusIndicator::PredictiveFailureAnalysis, "PredictiveFailureAnalysis"},
+    {StatusIndicator::Hotspare, "Hotspare"},
+    {StatusIndicator::InACriticalArray, "InACriticalArray"},
+    {StatusIndicator::InAFailedArray, "InAFailedArray"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(HotspareReplacementModeType, {
+    {HotspareReplacementModeType::Invalid, "Invalid"},
+    {HotspareReplacementModeType::Revertible, "Revertible"},
+    {HotspareReplacementModeType::NonRevertible, "NonRevertible"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(DataSanitizationType, {
+    {DataSanitizationType::Invalid, "Invalid"},
+    {DataSanitizationType::BlockErase, "BlockErase"},
+    {DataSanitizationType::CryptographicErase, "CryptographicErase"},
+    {DataSanitizationType::Overwrite, "Overwrite"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/ethernet_interface.hpp b/redfish-core/include/generated/enums/ethernet_interface.hpp
new file mode 100644
index 0000000..f69aba1
--- /dev/null
+++ b/redfish-core/include/generated/enums/ethernet_interface.hpp
@@ -0,0 +1,89 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace ethernet_interface
+{
+// clang-format off
+
+enum class LinkStatus{
+    Invalid,
+    LinkUp,
+    NoLink,
+    LinkDown,
+};
+
+enum class DHCPv6OperatingMode{
+    Invalid,
+    Stateful,
+    Stateless,
+    Disabled,
+    Enabled,
+};
+
+enum class DHCPFallback{
+    Invalid,
+    Static,
+    AutoConfig,
+    None,
+};
+
+enum class EthernetDeviceType{
+    Invalid,
+    Physical,
+    Virtual,
+};
+
+enum class TeamMode{
+    Invalid,
+    None,
+    RoundRobin,
+    ActiveBackup,
+    XOR,
+    Broadcast,
+    IEEE802_3ad,
+    AdaptiveTransmitLoadBalancing,
+    AdaptiveLoadBalancing,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(LinkStatus, {
+    {LinkStatus::Invalid, "Invalid"},
+    {LinkStatus::LinkUp, "LinkUp"},
+    {LinkStatus::NoLink, "NoLink"},
+    {LinkStatus::LinkDown, "LinkDown"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(DHCPv6OperatingMode, {
+    {DHCPv6OperatingMode::Invalid, "Invalid"},
+    {DHCPv6OperatingMode::Stateful, "Stateful"},
+    {DHCPv6OperatingMode::Stateless, "Stateless"},
+    {DHCPv6OperatingMode::Disabled, "Disabled"},
+    {DHCPv6OperatingMode::Enabled, "Enabled"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(DHCPFallback, {
+    {DHCPFallback::Invalid, "Invalid"},
+    {DHCPFallback::Static, "Static"},
+    {DHCPFallback::AutoConfig, "AutoConfig"},
+    {DHCPFallback::None, "None"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(EthernetDeviceType, {
+    {EthernetDeviceType::Invalid, "Invalid"},
+    {EthernetDeviceType::Physical, "Physical"},
+    {EthernetDeviceType::Virtual, "Virtual"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(TeamMode, {
+    {TeamMode::Invalid, "Invalid"},
+    {TeamMode::None, "None"},
+    {TeamMode::RoundRobin, "RoundRobin"},
+    {TeamMode::ActiveBackup, "ActiveBackup"},
+    {TeamMode::XOR, "XOR"},
+    {TeamMode::Broadcast, "Broadcast"},
+    {TeamMode::IEEE802_3ad, "IEEE802_3ad"},
+    {TeamMode::AdaptiveTransmitLoadBalancing, "AdaptiveTransmitLoadBalancing"},
+    {TeamMode::AdaptiveLoadBalancing, "AdaptiveLoadBalancing"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/event.hpp b/redfish-core/include/generated/enums/event.hpp
new file mode 100644
index 0000000..a88bac3
--- /dev/null
+++ b/redfish-core/include/generated/enums/event.hpp
@@ -0,0 +1,31 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace event
+{
+// clang-format off
+
+enum class EventType{
+    Invalid,
+    StatusChange,
+    ResourceUpdated,
+    ResourceAdded,
+    ResourceRemoved,
+    Alert,
+    MetricReport,
+    Other,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(EventType, {
+    {EventType::Invalid, "Invalid"},
+    {EventType::StatusChange, "StatusChange"},
+    {EventType::ResourceUpdated, "ResourceUpdated"},
+    {EventType::ResourceAdded, "ResourceAdded"},
+    {EventType::ResourceRemoved, "ResourceRemoved"},
+    {EventType::Alert, "Alert"},
+    {EventType::MetricReport, "MetricReport"},
+    {EventType::Other, "Other"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/event_destination.hpp b/redfish-core/include/generated/enums/event_destination.hpp
new file mode 100644
index 0000000..02fb8e6
--- /dev/null
+++ b/redfish-core/include/generated/enums/event_destination.hpp
@@ -0,0 +1,205 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace event_destination
+{
+// clang-format off
+
+enum class EventFormatType{
+    Invalid,
+    Event,
+    MetricReport,
+};
+
+enum class EventDestinationProtocol{
+    Invalid,
+    Redfish,
+    SNMPv1,
+    SNMPv2c,
+    SNMPv3,
+    SMTP,
+    SyslogTLS,
+    SyslogTCP,
+    SyslogUDP,
+    SyslogRELP,
+    OEM,
+};
+
+enum class SubscriptionType{
+    Invalid,
+    RedfishEvent,
+    SSE,
+    SNMPTrap,
+    SNMPInform,
+    Syslog,
+    OEM,
+};
+
+enum class DeliveryRetryPolicy{
+    Invalid,
+    TerminateAfterRetries,
+    SuspendRetries,
+    RetryForever,
+    RetryForeverWithBackoff,
+};
+
+enum class SNMPAuthenticationProtocols{
+    Invalid,
+    None,
+    CommunityString,
+    HMAC_MD5,
+    HMAC_SHA96,
+    HMAC128_SHA224,
+    HMAC192_SHA256,
+    HMAC256_SHA384,
+    HMAC384_SHA512,
+};
+
+enum class SNMPEncryptionProtocols{
+    Invalid,
+    None,
+    CBC_DES,
+    CFB128_AES128,
+};
+
+enum class SyslogSeverity{
+    Invalid,
+    Emergency,
+    Alert,
+    Critical,
+    Error,
+    Warning,
+    Notice,
+    Informational,
+    Debug,
+    All,
+};
+
+enum class SyslogFacility{
+    Invalid,
+    Kern,
+    User,
+    Mail,
+    Daemon,
+    Auth,
+    Syslog,
+    LPR,
+    News,
+    UUCP,
+    Cron,
+    Authpriv,
+    FTP,
+    NTP,
+    Security,
+    Console,
+    SolarisCron,
+    Local0,
+    Local1,
+    Local2,
+    Local3,
+    Local4,
+    Local5,
+    Local6,
+    Local7,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(EventFormatType, {
+    {EventFormatType::Invalid, "Invalid"},
+    {EventFormatType::Event, "Event"},
+    {EventFormatType::MetricReport, "MetricReport"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(EventDestinationProtocol, {
+    {EventDestinationProtocol::Invalid, "Invalid"},
+    {EventDestinationProtocol::Redfish, "Redfish"},
+    {EventDestinationProtocol::SNMPv1, "SNMPv1"},
+    {EventDestinationProtocol::SNMPv2c, "SNMPv2c"},
+    {EventDestinationProtocol::SNMPv3, "SNMPv3"},
+    {EventDestinationProtocol::SMTP, "SMTP"},
+    {EventDestinationProtocol::SyslogTLS, "SyslogTLS"},
+    {EventDestinationProtocol::SyslogTCP, "SyslogTCP"},
+    {EventDestinationProtocol::SyslogUDP, "SyslogUDP"},
+    {EventDestinationProtocol::SyslogRELP, "SyslogRELP"},
+    {EventDestinationProtocol::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SubscriptionType, {
+    {SubscriptionType::Invalid, "Invalid"},
+    {SubscriptionType::RedfishEvent, "RedfishEvent"},
+    {SubscriptionType::SSE, "SSE"},
+    {SubscriptionType::SNMPTrap, "SNMPTrap"},
+    {SubscriptionType::SNMPInform, "SNMPInform"},
+    {SubscriptionType::Syslog, "Syslog"},
+    {SubscriptionType::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(DeliveryRetryPolicy, {
+    {DeliveryRetryPolicy::Invalid, "Invalid"},
+    {DeliveryRetryPolicy::TerminateAfterRetries, "TerminateAfterRetries"},
+    {DeliveryRetryPolicy::SuspendRetries, "SuspendRetries"},
+    {DeliveryRetryPolicy::RetryForever, "RetryForever"},
+    {DeliveryRetryPolicy::RetryForeverWithBackoff, "RetryForeverWithBackoff"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SNMPAuthenticationProtocols, {
+    {SNMPAuthenticationProtocols::Invalid, "Invalid"},
+    {SNMPAuthenticationProtocols::None, "None"},
+    {SNMPAuthenticationProtocols::CommunityString, "CommunityString"},
+    {SNMPAuthenticationProtocols::HMAC_MD5, "HMAC_MD5"},
+    {SNMPAuthenticationProtocols::HMAC_SHA96, "HMAC_SHA96"},
+    {SNMPAuthenticationProtocols::HMAC128_SHA224, "HMAC128_SHA224"},
+    {SNMPAuthenticationProtocols::HMAC192_SHA256, "HMAC192_SHA256"},
+    {SNMPAuthenticationProtocols::HMAC256_SHA384, "HMAC256_SHA384"},
+    {SNMPAuthenticationProtocols::HMAC384_SHA512, "HMAC384_SHA512"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SNMPEncryptionProtocols, {
+    {SNMPEncryptionProtocols::Invalid, "Invalid"},
+    {SNMPEncryptionProtocols::None, "None"},
+    {SNMPEncryptionProtocols::CBC_DES, "CBC_DES"},
+    {SNMPEncryptionProtocols::CFB128_AES128, "CFB128_AES128"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SyslogSeverity, {
+    {SyslogSeverity::Invalid, "Invalid"},
+    {SyslogSeverity::Emergency, "Emergency"},
+    {SyslogSeverity::Alert, "Alert"},
+    {SyslogSeverity::Critical, "Critical"},
+    {SyslogSeverity::Error, "Error"},
+    {SyslogSeverity::Warning, "Warning"},
+    {SyslogSeverity::Notice, "Notice"},
+    {SyslogSeverity::Informational, "Informational"},
+    {SyslogSeverity::Debug, "Debug"},
+    {SyslogSeverity::All, "All"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SyslogFacility, {
+    {SyslogFacility::Invalid, "Invalid"},
+    {SyslogFacility::Kern, "Kern"},
+    {SyslogFacility::User, "User"},
+    {SyslogFacility::Mail, "Mail"},
+    {SyslogFacility::Daemon, "Daemon"},
+    {SyslogFacility::Auth, "Auth"},
+    {SyslogFacility::Syslog, "Syslog"},
+    {SyslogFacility::LPR, "LPR"},
+    {SyslogFacility::News, "News"},
+    {SyslogFacility::UUCP, "UUCP"},
+    {SyslogFacility::Cron, "Cron"},
+    {SyslogFacility::Authpriv, "Authpriv"},
+    {SyslogFacility::FTP, "FTP"},
+    {SyslogFacility::NTP, "NTP"},
+    {SyslogFacility::Security, "Security"},
+    {SyslogFacility::Console, "Console"},
+    {SyslogFacility::SolarisCron, "SolarisCron"},
+    {SyslogFacility::Local0, "Local0"},
+    {SyslogFacility::Local1, "Local1"},
+    {SyslogFacility::Local2, "Local2"},
+    {SyslogFacility::Local3, "Local3"},
+    {SyslogFacility::Local4, "Local4"},
+    {SyslogFacility::Local5, "Local5"},
+    {SyslogFacility::Local6, "Local6"},
+    {SyslogFacility::Local7, "Local7"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/event_service.hpp b/redfish-core/include/generated/enums/event_service.hpp
new file mode 100644
index 0000000..08a40d9
--- /dev/null
+++ b/redfish-core/include/generated/enums/event_service.hpp
@@ -0,0 +1,43 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace event_service
+{
+// clang-format off
+
+enum class SMTPConnectionProtocol{
+    Invalid,
+    None,
+    AutoDetect,
+    StartTLS,
+    TLS_SSL,
+};
+
+enum class SMTPAuthenticationMethods{
+    Invalid,
+    None,
+    AutoDetect,
+    Plain,
+    Login,
+    CRAM_MD5,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SMTPConnectionProtocol, {
+    {SMTPConnectionProtocol::Invalid, "Invalid"},
+    {SMTPConnectionProtocol::None, "None"},
+    {SMTPConnectionProtocol::AutoDetect, "AutoDetect"},
+    {SMTPConnectionProtocol::StartTLS, "StartTLS"},
+    {SMTPConnectionProtocol::TLS_SSL, "TLS_SSL"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SMTPAuthenticationMethods, {
+    {SMTPAuthenticationMethods::Invalid, "Invalid"},
+    {SMTPAuthenticationMethods::None, "None"},
+    {SMTPAuthenticationMethods::AutoDetect, "AutoDetect"},
+    {SMTPAuthenticationMethods::Plain, "Plain"},
+    {SMTPAuthenticationMethods::Login, "Login"},
+    {SMTPAuthenticationMethods::CRAM_MD5, "CRAM_MD5"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/ip_addresses.hpp b/redfish-core/include/generated/enums/ip_addresses.hpp
new file mode 100644
index 0000000..546b06a
--- /dev/null
+++ b/redfish-core/include/generated/enums/ip_addresses.hpp
@@ -0,0 +1,57 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace ip_addresses
+{
+// clang-format off
+
+enum class IPv4AddressOrigin{
+    Invalid,
+    Static,
+    DHCP,
+    BOOTP,
+    IPv4LinkLocal,
+};
+
+enum class IPv6AddressOrigin{
+    Invalid,
+    Static,
+    DHCPv6,
+    LinkLocal,
+    SLAAC,
+};
+
+enum class AddressState{
+    Invalid,
+    Preferred,
+    Deprecated,
+    Tentative,
+    Failed,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(IPv4AddressOrigin, {
+    {IPv4AddressOrigin::Invalid, "Invalid"},
+    {IPv4AddressOrigin::Static, "Static"},
+    {IPv4AddressOrigin::DHCP, "DHCP"},
+    {IPv4AddressOrigin::BOOTP, "BOOTP"},
+    {IPv4AddressOrigin::IPv4LinkLocal, "IPv4LinkLocal"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(IPv6AddressOrigin, {
+    {IPv6AddressOrigin::Invalid, "Invalid"},
+    {IPv6AddressOrigin::Static, "Static"},
+    {IPv6AddressOrigin::DHCPv6, "DHCPv6"},
+    {IPv6AddressOrigin::LinkLocal, "LinkLocal"},
+    {IPv6AddressOrigin::SLAAC, "SLAAC"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(AddressState, {
+    {AddressState::Invalid, "Invalid"},
+    {AddressState::Preferred, "Preferred"},
+    {AddressState::Deprecated, "Deprecated"},
+    {AddressState::Tentative, "Tentative"},
+    {AddressState::Failed, "Failed"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/log_entry.hpp b/redfish-core/include/generated/enums/log_entry.hpp
new file mode 100644
index 0000000..a36c7dc
--- /dev/null
+++ b/redfish-core/include/generated/enums/log_entry.hpp
@@ -0,0 +1,71 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace log_entry
+{
+// clang-format off
+
+enum class EventSeverity{
+    Invalid,
+    OK,
+    Warning,
+    Critical,
+};
+
+enum class LogEntryType{
+    Invalid,
+    Event,
+    SEL,
+    Oem,
+};
+
+enum class LogDiagnosticDataTypes{
+    Invalid,
+    Manager,
+    PreOS,
+    OS,
+    OEM,
+    CPER,
+    CPERSection,
+};
+
+enum class OriginatorTypes{
+    Invalid,
+    Client,
+    Internal,
+    SupportingService,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(EventSeverity, {
+    {EventSeverity::Invalid, "Invalid"},
+    {EventSeverity::OK, "OK"},
+    {EventSeverity::Warning, "Warning"},
+    {EventSeverity::Critical, "Critical"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(LogEntryType, {
+    {LogEntryType::Invalid, "Invalid"},
+    {LogEntryType::Event, "Event"},
+    {LogEntryType::SEL, "SEL"},
+    {LogEntryType::Oem, "Oem"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(LogDiagnosticDataTypes, {
+    {LogDiagnosticDataTypes::Invalid, "Invalid"},
+    {LogDiagnosticDataTypes::Manager, "Manager"},
+    {LogDiagnosticDataTypes::PreOS, "PreOS"},
+    {LogDiagnosticDataTypes::OS, "OS"},
+    {LogDiagnosticDataTypes::OEM, "OEM"},
+    {LogDiagnosticDataTypes::CPER, "CPER"},
+    {LogDiagnosticDataTypes::CPERSection, "CPERSection"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(OriginatorTypes, {
+    {OriginatorTypes::Invalid, "Invalid"},
+    {OriginatorTypes::Client, "Client"},
+    {OriginatorTypes::Internal, "Internal"},
+    {OriginatorTypes::SupportingService, "SupportingService"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/log_service.hpp b/redfish-core/include/generated/enums/log_service.hpp
new file mode 100644
index 0000000..caa5582
--- /dev/null
+++ b/redfish-core/include/generated/enums/log_service.hpp
@@ -0,0 +1,137 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace log_service
+{
+// clang-format off
+
+enum class OverWritePolicy{
+    Invalid,
+    Unknown,
+    WrapsWhenFull,
+    NeverOverWrites,
+};
+
+enum class LogEntryTypes{
+    Invalid,
+    Event,
+    SEL,
+    Multiple,
+    OEM,
+};
+
+enum class SyslogSeverity{
+    Invalid,
+    Emergency,
+    Alert,
+    Critical,
+    Error,
+    Warning,
+    Notice,
+    Informational,
+    Debug,
+    All,
+};
+
+enum class SyslogFacility{
+    Invalid,
+    Kern,
+    User,
+    Mail,
+    Daemon,
+    Auth,
+    Syslog,
+    LPR,
+    News,
+    UUCP,
+    Cron,
+    Authpriv,
+    FTP,
+    NTP,
+    Security,
+    Console,
+    SolarisCron,
+    Local0,
+    Local1,
+    Local2,
+    Local3,
+    Local4,
+    Local5,
+    Local6,
+    Local7,
+};
+
+enum class LogDiagnosticDataTypes{
+    Invalid,
+    Manager,
+    PreOS,
+    OS,
+    OEM,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(OverWritePolicy, {
+    {OverWritePolicy::Invalid, "Invalid"},
+    {OverWritePolicy::Unknown, "Unknown"},
+    {OverWritePolicy::WrapsWhenFull, "WrapsWhenFull"},
+    {OverWritePolicy::NeverOverWrites, "NeverOverWrites"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(LogEntryTypes, {
+    {LogEntryTypes::Invalid, "Invalid"},
+    {LogEntryTypes::Event, "Event"},
+    {LogEntryTypes::SEL, "SEL"},
+    {LogEntryTypes::Multiple, "Multiple"},
+    {LogEntryTypes::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SyslogSeverity, {
+    {SyslogSeverity::Invalid, "Invalid"},
+    {SyslogSeverity::Emergency, "Emergency"},
+    {SyslogSeverity::Alert, "Alert"},
+    {SyslogSeverity::Critical, "Critical"},
+    {SyslogSeverity::Error, "Error"},
+    {SyslogSeverity::Warning, "Warning"},
+    {SyslogSeverity::Notice, "Notice"},
+    {SyslogSeverity::Informational, "Informational"},
+    {SyslogSeverity::Debug, "Debug"},
+    {SyslogSeverity::All, "All"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SyslogFacility, {
+    {SyslogFacility::Invalid, "Invalid"},
+    {SyslogFacility::Kern, "Kern"},
+    {SyslogFacility::User, "User"},
+    {SyslogFacility::Mail, "Mail"},
+    {SyslogFacility::Daemon, "Daemon"},
+    {SyslogFacility::Auth, "Auth"},
+    {SyslogFacility::Syslog, "Syslog"},
+    {SyslogFacility::LPR, "LPR"},
+    {SyslogFacility::News, "News"},
+    {SyslogFacility::UUCP, "UUCP"},
+    {SyslogFacility::Cron, "Cron"},
+    {SyslogFacility::Authpriv, "Authpriv"},
+    {SyslogFacility::FTP, "FTP"},
+    {SyslogFacility::NTP, "NTP"},
+    {SyslogFacility::Security, "Security"},
+    {SyslogFacility::Console, "Console"},
+    {SyslogFacility::SolarisCron, "SolarisCron"},
+    {SyslogFacility::Local0, "Local0"},
+    {SyslogFacility::Local1, "Local1"},
+    {SyslogFacility::Local2, "Local2"},
+    {SyslogFacility::Local3, "Local3"},
+    {SyslogFacility::Local4, "Local4"},
+    {SyslogFacility::Local5, "Local5"},
+    {SyslogFacility::Local6, "Local6"},
+    {SyslogFacility::Local7, "Local7"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(LogDiagnosticDataTypes, {
+    {LogDiagnosticDataTypes::Invalid, "Invalid"},
+    {LogDiagnosticDataTypes::Manager, "Manager"},
+    {LogDiagnosticDataTypes::PreOS, "PreOS"},
+    {LogDiagnosticDataTypes::OS, "OS"},
+    {LogDiagnosticDataTypes::OEM, "OEM"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/manager.hpp b/redfish-core/include/generated/enums/manager.hpp
new file mode 100644
index 0000000..72dc0e8
--- /dev/null
+++ b/redfish-core/include/generated/enums/manager.hpp
@@ -0,0 +1,87 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace manager
+{
+// clang-format off
+
+enum class ManagerType{
+    Invalid,
+    ManagementController,
+    EnclosureManager,
+    BMC,
+    RackManager,
+    AuxiliaryController,
+    Service,
+};
+
+enum class SerialConnectTypesSupported{
+    Invalid,
+    SSH,
+    Telnet,
+    IPMI,
+    Oem,
+};
+
+enum class CommandConnectTypesSupported{
+    Invalid,
+    SSH,
+    Telnet,
+    IPMI,
+    Oem,
+};
+
+enum class GraphicalConnectTypesSupported{
+    Invalid,
+    KVMIP,
+    Oem,
+};
+
+enum class ResetToDefaultsType{
+    Invalid,
+    ResetAll,
+    PreserveNetworkAndUsers,
+    PreserveNetwork,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ManagerType, {
+    {ManagerType::Invalid, "Invalid"},
+    {ManagerType::ManagementController, "ManagementController"},
+    {ManagerType::EnclosureManager, "EnclosureManager"},
+    {ManagerType::BMC, "BMC"},
+    {ManagerType::RackManager, "RackManager"},
+    {ManagerType::AuxiliaryController, "AuxiliaryController"},
+    {ManagerType::Service, "Service"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SerialConnectTypesSupported, {
+    {SerialConnectTypesSupported::Invalid, "Invalid"},
+    {SerialConnectTypesSupported::SSH, "SSH"},
+    {SerialConnectTypesSupported::Telnet, "Telnet"},
+    {SerialConnectTypesSupported::IPMI, "IPMI"},
+    {SerialConnectTypesSupported::Oem, "Oem"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(CommandConnectTypesSupported, {
+    {CommandConnectTypesSupported::Invalid, "Invalid"},
+    {CommandConnectTypesSupported::SSH, "SSH"},
+    {CommandConnectTypesSupported::Telnet, "Telnet"},
+    {CommandConnectTypesSupported::IPMI, "IPMI"},
+    {CommandConnectTypesSupported::Oem, "Oem"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(GraphicalConnectTypesSupported, {
+    {GraphicalConnectTypesSupported::Invalid, "Invalid"},
+    {GraphicalConnectTypesSupported::KVMIP, "KVMIP"},
+    {GraphicalConnectTypesSupported::Oem, "Oem"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ResetToDefaultsType, {
+    {ResetToDefaultsType::Invalid, "Invalid"},
+    {ResetToDefaultsType::ResetAll, "ResetAll"},
+    {ResetToDefaultsType::PreserveNetworkAndUsers, "PreserveNetworkAndUsers"},
+    {ResetToDefaultsType::PreserveNetwork, "PreserveNetwork"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/manager_account.hpp b/redfish-core/include/generated/enums/manager_account.hpp
new file mode 100644
index 0000000..94bce32
--- /dev/null
+++ b/redfish-core/include/generated/enums/manager_account.hpp
@@ -0,0 +1,71 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace manager_account
+{
+// clang-format off
+
+enum class AccountTypes{
+    Invalid,
+    Redfish,
+    SNMP,
+    OEM,
+    HostConsole,
+    ManagerConsole,
+    IPMI,
+    KVMIP,
+    VirtualMedia,
+    WebUI,
+};
+
+enum class SNMPAuthenticationProtocols{
+    Invalid,
+    None,
+    HMAC_MD5,
+    HMAC_SHA96,
+    HMAC128_SHA224,
+    HMAC192_SHA256,
+    HMAC256_SHA384,
+    HMAC384_SHA512,
+};
+
+enum class SNMPEncryptionProtocols{
+    Invalid,
+    None,
+    CBC_DES,
+    CFB128_AES128,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(AccountTypes, {
+    {AccountTypes::Invalid, "Invalid"},
+    {AccountTypes::Redfish, "Redfish"},
+    {AccountTypes::SNMP, "SNMP"},
+    {AccountTypes::OEM, "OEM"},
+    {AccountTypes::HostConsole, "HostConsole"},
+    {AccountTypes::ManagerConsole, "ManagerConsole"},
+    {AccountTypes::IPMI, "IPMI"},
+    {AccountTypes::KVMIP, "KVMIP"},
+    {AccountTypes::VirtualMedia, "VirtualMedia"},
+    {AccountTypes::WebUI, "WebUI"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SNMPAuthenticationProtocols, {
+    {SNMPAuthenticationProtocols::Invalid, "Invalid"},
+    {SNMPAuthenticationProtocols::None, "None"},
+    {SNMPAuthenticationProtocols::HMAC_MD5, "HMAC_MD5"},
+    {SNMPAuthenticationProtocols::HMAC_SHA96, "HMAC_SHA96"},
+    {SNMPAuthenticationProtocols::HMAC128_SHA224, "HMAC128_SHA224"},
+    {SNMPAuthenticationProtocols::HMAC192_SHA256, "HMAC192_SHA256"},
+    {SNMPAuthenticationProtocols::HMAC256_SHA384, "HMAC256_SHA384"},
+    {SNMPAuthenticationProtocols::HMAC384_SHA512, "HMAC384_SHA512"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SNMPEncryptionProtocols, {
+    {SNMPEncryptionProtocols::Invalid, "Invalid"},
+    {SNMPEncryptionProtocols::None, "None"},
+    {SNMPEncryptionProtocols::CBC_DES, "CBC_DES"},
+    {SNMPEncryptionProtocols::CFB128_AES128, "CFB128_AES128"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/manager_network_protocol.hpp b/redfish-core/include/generated/enums/manager_network_protocol.hpp
new file mode 100644
index 0000000..aa203c9
--- /dev/null
+++ b/redfish-core/include/generated/enums/manager_network_protocol.hpp
@@ -0,0 +1,75 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace manager_network_protocol
+{
+// clang-format off
+
+enum class NotifyIPv6Scope{
+    Invalid,
+    Link,
+    Site,
+    Organization,
+};
+
+enum class SNMPCommunityAccessMode{
+    Invalid,
+    Full,
+    Limited,
+};
+
+enum class SNMPAuthenticationProtocols{
+    Invalid,
+    Account,
+    CommunityString,
+    HMAC_MD5,
+    HMAC_SHA96,
+    HMAC128_SHA224,
+    HMAC192_SHA256,
+    HMAC256_SHA384,
+    HMAC384_SHA512,
+};
+
+enum class SNMPEncryptionProtocols{
+    Invalid,
+    None,
+    Account,
+    CBC_DES,
+    CFB128_AES128,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(NotifyIPv6Scope, {
+    {NotifyIPv6Scope::Invalid, "Invalid"},
+    {NotifyIPv6Scope::Link, "Link"},
+    {NotifyIPv6Scope::Site, "Site"},
+    {NotifyIPv6Scope::Organization, "Organization"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SNMPCommunityAccessMode, {
+    {SNMPCommunityAccessMode::Invalid, "Invalid"},
+    {SNMPCommunityAccessMode::Full, "Full"},
+    {SNMPCommunityAccessMode::Limited, "Limited"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SNMPAuthenticationProtocols, {
+    {SNMPAuthenticationProtocols::Invalid, "Invalid"},
+    {SNMPAuthenticationProtocols::Account, "Account"},
+    {SNMPAuthenticationProtocols::CommunityString, "CommunityString"},
+    {SNMPAuthenticationProtocols::HMAC_MD5, "HMAC_MD5"},
+    {SNMPAuthenticationProtocols::HMAC_SHA96, "HMAC_SHA96"},
+    {SNMPAuthenticationProtocols::HMAC128_SHA224, "HMAC128_SHA224"},
+    {SNMPAuthenticationProtocols::HMAC192_SHA256, "HMAC192_SHA256"},
+    {SNMPAuthenticationProtocols::HMAC256_SHA384, "HMAC256_SHA384"},
+    {SNMPAuthenticationProtocols::HMAC384_SHA512, "HMAC384_SHA512"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SNMPEncryptionProtocols, {
+    {SNMPEncryptionProtocols::Invalid, "Invalid"},
+    {SNMPEncryptionProtocols::None, "None"},
+    {SNMPEncryptionProtocols::Account, "Account"},
+    {SNMPEncryptionProtocols::CBC_DES, "CBC_DES"},
+    {SNMPEncryptionProtocols::CFB128_AES128, "CFB128_AES128"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/memory.hpp b/redfish-core/include/generated/enums/memory.hpp
new file mode 100644
index 0000000..fe506fa
--- /dev/null
+++ b/redfish-core/include/generated/enums/memory.hpp
@@ -0,0 +1,209 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace memory
+{
+// clang-format off
+
+enum class MemoryType{
+    Invalid,
+    DRAM,
+    NVDIMM_N,
+    NVDIMM_F,
+    NVDIMM_P,
+    IntelOptane,
+};
+
+enum class MemoryDeviceType{
+    Invalid,
+    DDR,
+    DDR2,
+    DDR3,
+    DDR4,
+    DDR4_SDRAM,
+    DDR4E_SDRAM,
+    LPDDR4_SDRAM,
+    DDR3_SDRAM,
+    LPDDR3_SDRAM,
+    DDR2_SDRAM,
+    DDR2_SDRAM_FB_DIMM,
+    DDR2_SDRAM_FB_DIMM_PROBE,
+    DDR_SGRAM,
+    DDR_SDRAM,
+    ROM,
+    SDRAM,
+    EDO,
+    FastPageMode,
+    PipelinedNibble,
+    Logical,
+    HBM,
+    HBM2,
+    HBM3,
+    GDDR,
+    GDDR2,
+    GDDR3,
+    GDDR4,
+    GDDR5,
+    GDDR5X,
+    GDDR6,
+    DDR5,
+    OEM,
+};
+
+enum class BaseModuleType{
+    Invalid,
+    RDIMM,
+    UDIMM,
+    SO_DIMM,
+    LRDIMM,
+    Mini_RDIMM,
+    Mini_UDIMM,
+    SO_RDIMM_72b,
+    SO_UDIMM_72b,
+    SO_DIMM_16b,
+    SO_DIMM_32b,
+    Die,
+};
+
+enum class MemoryMedia{
+    Invalid,
+    DRAM,
+    NAND,
+    Intel3DXPoint,
+    Proprietary,
+};
+
+enum class SecurityStates{
+    Invalid,
+    Enabled,
+    Disabled,
+    Unlocked,
+    Locked,
+    Frozen,
+    Passphraselimit,
+};
+
+enum class ErrorCorrection{
+    Invalid,
+    NoECC,
+    SingleBitECC,
+    MultiBitECC,
+    AddressParity,
+};
+
+enum class MemoryClassification{
+    Invalid,
+    Volatile,
+    ByteAccessiblePersistent,
+    Block,
+};
+
+enum class OperatingMemoryModes{
+    Invalid,
+    Volatile,
+    PMEM,
+    Block,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MemoryType, {
+    {MemoryType::Invalid, "Invalid"},
+    {MemoryType::DRAM, "DRAM"},
+    {MemoryType::NVDIMM_N, "NVDIMM_N"},
+    {MemoryType::NVDIMM_F, "NVDIMM_F"},
+    {MemoryType::NVDIMM_P, "NVDIMM_P"},
+    {MemoryType::IntelOptane, "IntelOptane"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MemoryDeviceType, {
+    {MemoryDeviceType::Invalid, "Invalid"},
+    {MemoryDeviceType::DDR, "DDR"},
+    {MemoryDeviceType::DDR2, "DDR2"},
+    {MemoryDeviceType::DDR3, "DDR3"},
+    {MemoryDeviceType::DDR4, "DDR4"},
+    {MemoryDeviceType::DDR4_SDRAM, "DDR4_SDRAM"},
+    {MemoryDeviceType::DDR4E_SDRAM, "DDR4E_SDRAM"},
+    {MemoryDeviceType::LPDDR4_SDRAM, "LPDDR4_SDRAM"},
+    {MemoryDeviceType::DDR3_SDRAM, "DDR3_SDRAM"},
+    {MemoryDeviceType::LPDDR3_SDRAM, "LPDDR3_SDRAM"},
+    {MemoryDeviceType::DDR2_SDRAM, "DDR2_SDRAM"},
+    {MemoryDeviceType::DDR2_SDRAM_FB_DIMM, "DDR2_SDRAM_FB_DIMM"},
+    {MemoryDeviceType::DDR2_SDRAM_FB_DIMM_PROBE, "DDR2_SDRAM_FB_DIMM_PROBE"},
+    {MemoryDeviceType::DDR_SGRAM, "DDR_SGRAM"},
+    {MemoryDeviceType::DDR_SDRAM, "DDR_SDRAM"},
+    {MemoryDeviceType::ROM, "ROM"},
+    {MemoryDeviceType::SDRAM, "SDRAM"},
+    {MemoryDeviceType::EDO, "EDO"},
+    {MemoryDeviceType::FastPageMode, "FastPageMode"},
+    {MemoryDeviceType::PipelinedNibble, "PipelinedNibble"},
+    {MemoryDeviceType::Logical, "Logical"},
+    {MemoryDeviceType::HBM, "HBM"},
+    {MemoryDeviceType::HBM2, "HBM2"},
+    {MemoryDeviceType::HBM3, "HBM3"},
+    {MemoryDeviceType::GDDR, "GDDR"},
+    {MemoryDeviceType::GDDR2, "GDDR2"},
+    {MemoryDeviceType::GDDR3, "GDDR3"},
+    {MemoryDeviceType::GDDR4, "GDDR4"},
+    {MemoryDeviceType::GDDR5, "GDDR5"},
+    {MemoryDeviceType::GDDR5X, "GDDR5X"},
+    {MemoryDeviceType::GDDR6, "GDDR6"},
+    {MemoryDeviceType::DDR5, "DDR5"},
+    {MemoryDeviceType::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(BaseModuleType, {
+    {BaseModuleType::Invalid, "Invalid"},
+    {BaseModuleType::RDIMM, "RDIMM"},
+    {BaseModuleType::UDIMM, "UDIMM"},
+    {BaseModuleType::SO_DIMM, "SO_DIMM"},
+    {BaseModuleType::LRDIMM, "LRDIMM"},
+    {BaseModuleType::Mini_RDIMM, "Mini_RDIMM"},
+    {BaseModuleType::Mini_UDIMM, "Mini_UDIMM"},
+    {BaseModuleType::SO_RDIMM_72b, "SO_RDIMM_72b"},
+    {BaseModuleType::SO_UDIMM_72b, "SO_UDIMM_72b"},
+    {BaseModuleType::SO_DIMM_16b, "SO_DIMM_16b"},
+    {BaseModuleType::SO_DIMM_32b, "SO_DIMM_32b"},
+    {BaseModuleType::Die, "Die"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MemoryMedia, {
+    {MemoryMedia::Invalid, "Invalid"},
+    {MemoryMedia::DRAM, "DRAM"},
+    {MemoryMedia::NAND, "NAND"},
+    {MemoryMedia::Intel3DXPoint, "Intel3DXPoint"},
+    {MemoryMedia::Proprietary, "Proprietary"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SecurityStates, {
+    {SecurityStates::Invalid, "Invalid"},
+    {SecurityStates::Enabled, "Enabled"},
+    {SecurityStates::Disabled, "Disabled"},
+    {SecurityStates::Unlocked, "Unlocked"},
+    {SecurityStates::Locked, "Locked"},
+    {SecurityStates::Frozen, "Frozen"},
+    {SecurityStates::Passphraselimit, "Passphraselimit"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ErrorCorrection, {
+    {ErrorCorrection::Invalid, "Invalid"},
+    {ErrorCorrection::NoECC, "NoECC"},
+    {ErrorCorrection::SingleBitECC, "SingleBitECC"},
+    {ErrorCorrection::MultiBitECC, "MultiBitECC"},
+    {ErrorCorrection::AddressParity, "AddressParity"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MemoryClassification, {
+    {MemoryClassification::Invalid, "Invalid"},
+    {MemoryClassification::Volatile, "Volatile"},
+    {MemoryClassification::ByteAccessiblePersistent, "ByteAccessiblePersistent"},
+    {MemoryClassification::Block, "Block"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(OperatingMemoryModes, {
+    {OperatingMemoryModes::Invalid, "Invalid"},
+    {OperatingMemoryModes::Volatile, "Volatile"},
+    {OperatingMemoryModes::PMEM, "PMEM"},
+    {OperatingMemoryModes::Block, "Block"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/message_registry.hpp b/redfish-core/include/generated/enums/message_registry.hpp
new file mode 100644
index 0000000..1e90e96
--- /dev/null
+++ b/redfish-core/include/generated/enums/message_registry.hpp
@@ -0,0 +1,31 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace message_registry
+{
+// clang-format off
+
+enum class ParamType{
+    Invalid,
+    string,
+    number,
+};
+
+enum class ClearingType{
+    Invalid,
+    SameOriginOfCondition,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ParamType, {
+    {ParamType::Invalid, "Invalid"},
+    {ParamType::string, "string"},
+    {ParamType::number, "number"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ClearingType, {
+    {ClearingType::Invalid, "Invalid"},
+    {ClearingType::SameOriginOfCondition, "SameOriginOfCondition"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/metric_definition.hpp b/redfish-core/include/generated/enums/metric_definition.hpp
new file mode 100644
index 0000000..4bc3c59
--- /dev/null
+++ b/redfish-core/include/generated/enums/metric_definition.hpp
@@ -0,0 +1,95 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace metric_definition
+{
+// clang-format off
+
+enum class MetricType{
+    Invalid,
+    Numeric,
+    Discrete,
+    Gauge,
+    Counter,
+    Countdown,
+    String,
+};
+
+enum class ImplementationType{
+    Invalid,
+    PhysicalSensor,
+    Calculated,
+    Synthesized,
+    DigitalMeter,
+};
+
+enum class MetricDataType{
+    Invalid,
+    Boolean,
+    DateTime,
+    Decimal,
+    Integer,
+    String,
+    Enumeration,
+};
+
+enum class Calculable{
+    Invalid,
+    NonCalculatable,
+    Summable,
+    NonSummable,
+};
+
+enum class CalculationAlgorithmEnum{
+    Invalid,
+    Average,
+    Maximum,
+    Minimum,
+    OEM,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MetricType, {
+    {MetricType::Invalid, "Invalid"},
+    {MetricType::Numeric, "Numeric"},
+    {MetricType::Discrete, "Discrete"},
+    {MetricType::Gauge, "Gauge"},
+    {MetricType::Counter, "Counter"},
+    {MetricType::Countdown, "Countdown"},
+    {MetricType::String, "String"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ImplementationType, {
+    {ImplementationType::Invalid, "Invalid"},
+    {ImplementationType::PhysicalSensor, "PhysicalSensor"},
+    {ImplementationType::Calculated, "Calculated"},
+    {ImplementationType::Synthesized, "Synthesized"},
+    {ImplementationType::DigitalMeter, "DigitalMeter"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MetricDataType, {
+    {MetricDataType::Invalid, "Invalid"},
+    {MetricDataType::Boolean, "Boolean"},
+    {MetricDataType::DateTime, "DateTime"},
+    {MetricDataType::Decimal, "Decimal"},
+    {MetricDataType::Integer, "Integer"},
+    {MetricDataType::String, "String"},
+    {MetricDataType::Enumeration, "Enumeration"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(Calculable, {
+    {Calculable::Invalid, "Invalid"},
+    {Calculable::NonCalculatable, "NonCalculatable"},
+    {Calculable::Summable, "Summable"},
+    {Calculable::NonSummable, "NonSummable"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(CalculationAlgorithmEnum, {
+    {CalculationAlgorithmEnum::Invalid, "Invalid"},
+    {CalculationAlgorithmEnum::Average, "Average"},
+    {CalculationAlgorithmEnum::Maximum, "Maximum"},
+    {CalculationAlgorithmEnum::Minimum, "Minimum"},
+    {CalculationAlgorithmEnum::OEM, "OEM"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/metric_report_definition.hpp b/redfish-core/include/generated/enums/metric_report_definition.hpp
new file mode 100644
index 0000000..4ffa111
--- /dev/null
+++ b/redfish-core/include/generated/enums/metric_report_definition.hpp
@@ -0,0 +1,81 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace metric_report_definition
+{
+// clang-format off
+
+enum class MetricReportDefinitionType{
+    Invalid,
+    Periodic,
+    OnChange,
+    OnRequest,
+};
+
+enum class ReportActionsEnum{
+    Invalid,
+    LogToMetricReportsCollection,
+    RedfishEvent,
+};
+
+enum class ReportUpdatesEnum{
+    Invalid,
+    Overwrite,
+    AppendWrapsWhenFull,
+    AppendStopsWhenFull,
+    NewReport,
+};
+
+enum class CalculationAlgorithmEnum{
+    Invalid,
+    Average,
+    Maximum,
+    Minimum,
+    Summation,
+};
+
+enum class CollectionTimeScope{
+    Invalid,
+    Point,
+    Interval,
+    StartupInterval,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MetricReportDefinitionType, {
+    {MetricReportDefinitionType::Invalid, "Invalid"},
+    {MetricReportDefinitionType::Periodic, "Periodic"},
+    {MetricReportDefinitionType::OnChange, "OnChange"},
+    {MetricReportDefinitionType::OnRequest, "OnRequest"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ReportActionsEnum, {
+    {ReportActionsEnum::Invalid, "Invalid"},
+    {ReportActionsEnum::LogToMetricReportsCollection, "LogToMetricReportsCollection"},
+    {ReportActionsEnum::RedfishEvent, "RedfishEvent"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ReportUpdatesEnum, {
+    {ReportUpdatesEnum::Invalid, "Invalid"},
+    {ReportUpdatesEnum::Overwrite, "Overwrite"},
+    {ReportUpdatesEnum::AppendWrapsWhenFull, "AppendWrapsWhenFull"},
+    {ReportUpdatesEnum::AppendStopsWhenFull, "AppendStopsWhenFull"},
+    {ReportUpdatesEnum::NewReport, "NewReport"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(CalculationAlgorithmEnum, {
+    {CalculationAlgorithmEnum::Invalid, "Invalid"},
+    {CalculationAlgorithmEnum::Average, "Average"},
+    {CalculationAlgorithmEnum::Maximum, "Maximum"},
+    {CalculationAlgorithmEnum::Minimum, "Minimum"},
+    {CalculationAlgorithmEnum::Summation, "Summation"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(CollectionTimeScope, {
+    {CollectionTimeScope::Invalid, "Invalid"},
+    {CollectionTimeScope::Point, "Point"},
+    {CollectionTimeScope::Interval, "Interval"},
+    {CollectionTimeScope::StartupInterval, "StartupInterval"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/oem_computer_system.hpp b/redfish-core/include/generated/enums/oem_computer_system.hpp
new file mode 100644
index 0000000..a1a4a6e
--- /dev/null
+++ b/redfish-core/include/generated/enums/oem_computer_system.hpp
@@ -0,0 +1,23 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace oem_computer_system
+{
+// clang-format off
+
+enum class FirmwareProvisioningStatus{
+    Invalid,
+    NotProvisioned,
+    ProvisionedButNotLocked,
+    ProvisionedAndLocked,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(FirmwareProvisioningStatus, {
+    {FirmwareProvisioningStatus::Invalid, "Invalid"},
+    {FirmwareProvisioningStatus::NotProvisioned, "NotProvisioned"},
+    {FirmwareProvisioningStatus::ProvisionedButNotLocked, "ProvisionedButNotLocked"},
+    {FirmwareProvisioningStatus::ProvisionedAndLocked, "ProvisionedAndLocked"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/pcie_device.hpp b/redfish-core/include/generated/enums/pcie_device.hpp
new file mode 100644
index 0000000..d87f573
--- /dev/null
+++ b/redfish-core/include/generated/enums/pcie_device.hpp
@@ -0,0 +1,83 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace pcie_device
+{
+// clang-format off
+
+enum class PCIeTypes{
+    Invalid,
+    Gen1,
+    Gen2,
+    Gen3,
+    Gen4,
+    Gen5,
+};
+
+enum class DeviceType{
+    Invalid,
+    SingleFunction,
+    MultiFunction,
+    Simulated,
+    Retimer,
+};
+
+enum class SlotType{
+    Invalid,
+    FullLength,
+    HalfLength,
+    LowProfile,
+    Mini,
+    M2,
+    OEM,
+    OCP3Small,
+    OCP3Large,
+    U2,
+};
+
+enum class LaneSplittingType{
+    Invalid,
+    None,
+    Bridged,
+    Bifurcated,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PCIeTypes, {
+    {PCIeTypes::Invalid, "Invalid"},
+    {PCIeTypes::Gen1, "Gen1"},
+    {PCIeTypes::Gen2, "Gen2"},
+    {PCIeTypes::Gen3, "Gen3"},
+    {PCIeTypes::Gen4, "Gen4"},
+    {PCIeTypes::Gen5, "Gen5"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(DeviceType, {
+    {DeviceType::Invalid, "Invalid"},
+    {DeviceType::SingleFunction, "SingleFunction"},
+    {DeviceType::MultiFunction, "MultiFunction"},
+    {DeviceType::Simulated, "Simulated"},
+    {DeviceType::Retimer, "Retimer"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SlotType, {
+    {SlotType::Invalid, "Invalid"},
+    {SlotType::FullLength, "FullLength"},
+    {SlotType::HalfLength, "HalfLength"},
+    {SlotType::LowProfile, "LowProfile"},
+    {SlotType::Mini, "Mini"},
+    {SlotType::M2, "M2"},
+    {SlotType::OEM, "OEM"},
+    {SlotType::OCP3Small, "OCP3Small"},
+    {SlotType::OCP3Large, "OCP3Large"},
+    {SlotType::U2, "U2"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(LaneSplittingType, {
+    {LaneSplittingType::Invalid, "Invalid"},
+    {LaneSplittingType::None, "None"},
+    {LaneSplittingType::Bridged, "Bridged"},
+    {LaneSplittingType::Bifurcated, "Bifurcated"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/pcie_function.hpp b/redfish-core/include/generated/enums/pcie_function.hpp
new file mode 100644
index 0000000..8f3f032
--- /dev/null
+++ b/redfish-core/include/generated/enums/pcie_function.hpp
@@ -0,0 +1,75 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace pcie_function
+{
+// clang-format off
+
+enum class DeviceClass{
+    Invalid,
+    UnclassifiedDevice,
+    MassStorageController,
+    NetworkController,
+    DisplayController,
+    MultimediaController,
+    MemoryController,
+    Bridge,
+    CommunicationController,
+    GenericSystemPeripheral,
+    InputDeviceController,
+    DockingStation,
+    Processor,
+    SerialBusController,
+    WirelessController,
+    IntelligentController,
+    SatelliteCommunicationsController,
+    EncryptionController,
+    SignalProcessingController,
+    ProcessingAccelerators,
+    NonEssentialInstrumentation,
+    Coprocessor,
+    UnassignedClass,
+    Other,
+};
+
+enum class FunctionType{
+    Invalid,
+    Physical,
+    Virtual,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(DeviceClass, {
+    {DeviceClass::Invalid, "Invalid"},
+    {DeviceClass::UnclassifiedDevice, "UnclassifiedDevice"},
+    {DeviceClass::MassStorageController, "MassStorageController"},
+    {DeviceClass::NetworkController, "NetworkController"},
+    {DeviceClass::DisplayController, "DisplayController"},
+    {DeviceClass::MultimediaController, "MultimediaController"},
+    {DeviceClass::MemoryController, "MemoryController"},
+    {DeviceClass::Bridge, "Bridge"},
+    {DeviceClass::CommunicationController, "CommunicationController"},
+    {DeviceClass::GenericSystemPeripheral, "GenericSystemPeripheral"},
+    {DeviceClass::InputDeviceController, "InputDeviceController"},
+    {DeviceClass::DockingStation, "DockingStation"},
+    {DeviceClass::Processor, "Processor"},
+    {DeviceClass::SerialBusController, "SerialBusController"},
+    {DeviceClass::WirelessController, "WirelessController"},
+    {DeviceClass::IntelligentController, "IntelligentController"},
+    {DeviceClass::SatelliteCommunicationsController, "SatelliteCommunicationsController"},
+    {DeviceClass::EncryptionController, "EncryptionController"},
+    {DeviceClass::SignalProcessingController, "SignalProcessingController"},
+    {DeviceClass::ProcessingAccelerators, "ProcessingAccelerators"},
+    {DeviceClass::NonEssentialInstrumentation, "NonEssentialInstrumentation"},
+    {DeviceClass::Coprocessor, "Coprocessor"},
+    {DeviceClass::UnassignedClass, "UnassignedClass"},
+    {DeviceClass::Other, "Other"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(FunctionType, {
+    {FunctionType::Invalid, "Invalid"},
+    {FunctionType::Physical, "Physical"},
+    {FunctionType::Virtual, "Virtual"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/pcie_slots.hpp b/redfish-core/include/generated/enums/pcie_slots.hpp
new file mode 100644
index 0000000..38221d0
--- /dev/null
+++ b/redfish-core/include/generated/enums/pcie_slots.hpp
@@ -0,0 +1,35 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace pcie_slots
+{
+// clang-format off
+
+enum class SlotTypes{
+    Invalid,
+    FullLength,
+    HalfLength,
+    LowProfile,
+    Mini,
+    M2,
+    OEM,
+    OCP3Small,
+    OCP3Large,
+    U2,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SlotTypes, {
+    {SlotTypes::Invalid, "Invalid"},
+    {SlotTypes::FullLength, "FullLength"},
+    {SlotTypes::HalfLength, "HalfLength"},
+    {SlotTypes::LowProfile, "LowProfile"},
+    {SlotTypes::Mini, "Mini"},
+    {SlotTypes::M2, "M2"},
+    {SlotTypes::OEM, "OEM"},
+    {SlotTypes::OCP3Small, "OCP3Small"},
+    {SlotTypes::OCP3Large, "OCP3Large"},
+    {SlotTypes::U2, "U2"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/physical_context.hpp b/redfish-core/include/generated/enums/physical_context.hpp
new file mode 100644
index 0000000..aead54e
--- /dev/null
+++ b/redfish-core/include/generated/enums/physical_context.hpp
@@ -0,0 +1,143 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace physical_context
+{
+// clang-format off
+
+enum class PhysicalContext{
+    Invalid,
+    Room,
+    Intake,
+    Exhaust,
+    LiquidInlet,
+    LiquidOutlet,
+    Front,
+    Back,
+    Upper,
+    Lower,
+    CPU,
+    CPUSubsystem,
+    GPU,
+    GPUSubsystem,
+    FPGA,
+    Accelerator,
+    ASIC,
+    Backplane,
+    SystemBoard,
+    PowerSupply,
+    PowerSubsystem,
+    VoltageRegulator,
+    Rectifier,
+    StorageDevice,
+    NetworkingDevice,
+    ComputeBay,
+    StorageBay,
+    NetworkBay,
+    ExpansionBay,
+    PowerSupplyBay,
+    Memory,
+    MemorySubsystem,
+    Chassis,
+    Fan,
+    CoolingSubsystem,
+    Motor,
+    Transformer,
+    ACUtilityInput,
+    ACStaticBypassInput,
+    ACMaintenanceBypassInput,
+    DCBus,
+    ACOutput,
+    ACInput,
+    TrustedModule,
+    Board,
+    Transceiver,
+    Battery,
+    Pump,
+};
+
+enum class PhysicalSubContext{
+    Invalid,
+    Input,
+    Output,
+};
+
+enum class LogicalContext{
+    Invalid,
+    Capacity,
+    Environment,
+    Network,
+    Performance,
+    Security,
+    Storage,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PhysicalContext, {
+    {PhysicalContext::Invalid, "Invalid"},
+    {PhysicalContext::Room, "Room"},
+    {PhysicalContext::Intake, "Intake"},
+    {PhysicalContext::Exhaust, "Exhaust"},
+    {PhysicalContext::LiquidInlet, "LiquidInlet"},
+    {PhysicalContext::LiquidOutlet, "LiquidOutlet"},
+    {PhysicalContext::Front, "Front"},
+    {PhysicalContext::Back, "Back"},
+    {PhysicalContext::Upper, "Upper"},
+    {PhysicalContext::Lower, "Lower"},
+    {PhysicalContext::CPU, "CPU"},
+    {PhysicalContext::CPUSubsystem, "CPUSubsystem"},
+    {PhysicalContext::GPU, "GPU"},
+    {PhysicalContext::GPUSubsystem, "GPUSubsystem"},
+    {PhysicalContext::FPGA, "FPGA"},
+    {PhysicalContext::Accelerator, "Accelerator"},
+    {PhysicalContext::ASIC, "ASIC"},
+    {PhysicalContext::Backplane, "Backplane"},
+    {PhysicalContext::SystemBoard, "SystemBoard"},
+    {PhysicalContext::PowerSupply, "PowerSupply"},
+    {PhysicalContext::PowerSubsystem, "PowerSubsystem"},
+    {PhysicalContext::VoltageRegulator, "VoltageRegulator"},
+    {PhysicalContext::Rectifier, "Rectifier"},
+    {PhysicalContext::StorageDevice, "StorageDevice"},
+    {PhysicalContext::NetworkingDevice, "NetworkingDevice"},
+    {PhysicalContext::ComputeBay, "ComputeBay"},
+    {PhysicalContext::StorageBay, "StorageBay"},
+    {PhysicalContext::NetworkBay, "NetworkBay"},
+    {PhysicalContext::ExpansionBay, "ExpansionBay"},
+    {PhysicalContext::PowerSupplyBay, "PowerSupplyBay"},
+    {PhysicalContext::Memory, "Memory"},
+    {PhysicalContext::MemorySubsystem, "MemorySubsystem"},
+    {PhysicalContext::Chassis, "Chassis"},
+    {PhysicalContext::Fan, "Fan"},
+    {PhysicalContext::CoolingSubsystem, "CoolingSubsystem"},
+    {PhysicalContext::Motor, "Motor"},
+    {PhysicalContext::Transformer, "Transformer"},
+    {PhysicalContext::ACUtilityInput, "ACUtilityInput"},
+    {PhysicalContext::ACStaticBypassInput, "ACStaticBypassInput"},
+    {PhysicalContext::ACMaintenanceBypassInput, "ACMaintenanceBypassInput"},
+    {PhysicalContext::DCBus, "DCBus"},
+    {PhysicalContext::ACOutput, "ACOutput"},
+    {PhysicalContext::ACInput, "ACInput"},
+    {PhysicalContext::TrustedModule, "TrustedModule"},
+    {PhysicalContext::Board, "Board"},
+    {PhysicalContext::Transceiver, "Transceiver"},
+    {PhysicalContext::Battery, "Battery"},
+    {PhysicalContext::Pump, "Pump"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PhysicalSubContext, {
+    {PhysicalSubContext::Invalid, "Invalid"},
+    {PhysicalSubContext::Input, "Input"},
+    {PhysicalSubContext::Output, "Output"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(LogicalContext, {
+    {LogicalContext::Invalid, "Invalid"},
+    {LogicalContext::Capacity, "Capacity"},
+    {LogicalContext::Environment, "Environment"},
+    {LogicalContext::Network, "Network"},
+    {LogicalContext::Performance, "Performance"},
+    {LogicalContext::Security, "Security"},
+    {LogicalContext::Storage, "Storage"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/power.hpp b/redfish-core/include/generated/enums/power.hpp
new file mode 100644
index 0000000..89e2ac8
--- /dev/null
+++ b/redfish-core/include/generated/enums/power.hpp
@@ -0,0 +1,85 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace power
+{
+// clang-format off
+
+enum class PowerLimitException{
+    Invalid,
+    NoAction,
+    HardPowerOff,
+    LogEventOnly,
+    Oem,
+};
+
+enum class PowerSupplyType{
+    Invalid,
+    Unknown,
+    AC,
+    DC,
+    ACorDC,
+};
+
+enum class LineInputVoltageType{
+    Invalid,
+    Unknown,
+    ACLowLine,
+    ACMidLine,
+    ACHighLine,
+    DCNeg48V,
+    DC380V,
+    AC120V,
+    AC240V,
+    AC277V,
+    ACandDCWideRange,
+    ACWideRange,
+    DC240V,
+};
+
+enum class InputType{
+    Invalid,
+    AC,
+    DC,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PowerLimitException, {
+    {PowerLimitException::Invalid, "Invalid"},
+    {PowerLimitException::NoAction, "NoAction"},
+    {PowerLimitException::HardPowerOff, "HardPowerOff"},
+    {PowerLimitException::LogEventOnly, "LogEventOnly"},
+    {PowerLimitException::Oem, "Oem"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PowerSupplyType, {
+    {PowerSupplyType::Invalid, "Invalid"},
+    {PowerSupplyType::Unknown, "Unknown"},
+    {PowerSupplyType::AC, "AC"},
+    {PowerSupplyType::DC, "DC"},
+    {PowerSupplyType::ACorDC, "ACorDC"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(LineInputVoltageType, {
+    {LineInputVoltageType::Invalid, "Invalid"},
+    {LineInputVoltageType::Unknown, "Unknown"},
+    {LineInputVoltageType::ACLowLine, "ACLowLine"},
+    {LineInputVoltageType::ACMidLine, "ACMidLine"},
+    {LineInputVoltageType::ACHighLine, "ACHighLine"},
+    {LineInputVoltageType::DCNeg48V, "DCNeg48V"},
+    {LineInputVoltageType::DC380V, "DC380V"},
+    {LineInputVoltageType::AC120V, "AC120V"},
+    {LineInputVoltageType::AC240V, "AC240V"},
+    {LineInputVoltageType::AC277V, "AC277V"},
+    {LineInputVoltageType::ACandDCWideRange, "ACandDCWideRange"},
+    {LineInputVoltageType::ACWideRange, "ACWideRange"},
+    {LineInputVoltageType::DC240V, "DC240V"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(InputType, {
+    {InputType::Invalid, "Invalid"},
+    {InputType::AC, "AC"},
+    {InputType::DC, "DC"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/power_supply.hpp b/redfish-core/include/generated/enums/power_supply.hpp
new file mode 100644
index 0000000..898a7a0
--- /dev/null
+++ b/redfish-core/include/generated/enums/power_supply.hpp
@@ -0,0 +1,39 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace power_supply
+{
+// clang-format off
+
+enum class PowerSupplyType{
+    Invalid,
+    AC,
+    DC,
+    ACorDC,
+    DCRegulator,
+};
+
+enum class LineStatus{
+    Invalid,
+    Normal,
+    LossOfInput,
+    OutOfRange,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PowerSupplyType, {
+    {PowerSupplyType::Invalid, "Invalid"},
+    {PowerSupplyType::AC, "AC"},
+    {PowerSupplyType::DC, "DC"},
+    {PowerSupplyType::ACorDC, "ACorDC"},
+    {PowerSupplyType::DCRegulator, "DCRegulator"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(LineStatus, {
+    {LineStatus::Invalid, "Invalid"},
+    {LineStatus::Normal, "Normal"},
+    {LineStatus::LossOfInput, "LossOfInput"},
+    {LineStatus::OutOfRange, "OutOfRange"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/privileges.hpp b/redfish-core/include/generated/enums/privileges.hpp
new file mode 100644
index 0000000..3084131
--- /dev/null
+++ b/redfish-core/include/generated/enums/privileges.hpp
@@ -0,0 +1,39 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace privileges
+{
+// clang-format off
+
+enum class PrivilegeType{
+    Invalid,
+    Login,
+    ConfigureManager,
+    ConfigureUsers,
+    ConfigureSelf,
+    ConfigureComponents,
+    NoAuth,
+    ConfigureCompositionInfrastructure,
+    AdministrateSystems,
+    OperateSystems,
+    AdministrateStorage,
+    OperateStorageBackup,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PrivilegeType, {
+    {PrivilegeType::Invalid, "Invalid"},
+    {PrivilegeType::Login, "Login"},
+    {PrivilegeType::ConfigureManager, "ConfigureManager"},
+    {PrivilegeType::ConfigureUsers, "ConfigureUsers"},
+    {PrivilegeType::ConfigureSelf, "ConfigureSelf"},
+    {PrivilegeType::ConfigureComponents, "ConfigureComponents"},
+    {PrivilegeType::NoAuth, "NoAuth"},
+    {PrivilegeType::ConfigureCompositionInfrastructure, "ConfigureCompositionInfrastructure"},
+    {PrivilegeType::AdministrateSystems, "AdministrateSystems"},
+    {PrivilegeType::OperateSystems, "OperateSystems"},
+    {PrivilegeType::AdministrateStorage, "AdministrateStorage"},
+    {PrivilegeType::OperateStorageBackup, "OperateStorageBackup"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/processor.hpp b/redfish-core/include/generated/enums/processor.hpp
new file mode 100644
index 0000000..29e6fae
--- /dev/null
+++ b/redfish-core/include/generated/enums/processor.hpp
@@ -0,0 +1,173 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace processor
+{
+// clang-format off
+
+enum class ProcessorType{
+    Invalid,
+    CPU,
+    GPU,
+    FPGA,
+    DSP,
+    Accelerator,
+    Core,
+    Thread,
+    OEM,
+};
+
+enum class ProcessorMemoryType{
+    Invalid,
+    L1Cache,
+    L2Cache,
+    L3Cache,
+    L4Cache,
+    L5Cache,
+    L6Cache,
+    L7Cache,
+    HBM1,
+    HBM2,
+    HBM3,
+    SGRAM,
+    GDDR,
+    GDDR2,
+    GDDR3,
+    GDDR4,
+    GDDR5,
+    GDDR5X,
+    GDDR6,
+    DDR,
+    DDR2,
+    DDR3,
+    DDR4,
+    DDR5,
+    SDRAM,
+    SRAM,
+    Flash,
+    OEM,
+};
+
+enum class FpgaType{
+    Invalid,
+    Integrated,
+    Discrete,
+};
+
+enum class SystemInterfaceType{
+    Invalid,
+    QPI,
+    UPI,
+    PCIe,
+    Ethernet,
+    AMBA,
+    CCIX,
+    CXL,
+    OEM,
+};
+
+enum class TurboState{
+    Invalid,
+    Enabled,
+    Disabled,
+};
+
+enum class BaseSpeedPriorityState{
+    Invalid,
+    Enabled,
+    Disabled,
+};
+
+enum class ThrottleCause{
+    Invalid,
+    PowerLimit,
+    ThermalLimit,
+    ClockLimit,
+    Unknown,
+    OEM,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ProcessorType, {
+    {ProcessorType::Invalid, "Invalid"},
+    {ProcessorType::CPU, "CPU"},
+    {ProcessorType::GPU, "GPU"},
+    {ProcessorType::FPGA, "FPGA"},
+    {ProcessorType::DSP, "DSP"},
+    {ProcessorType::Accelerator, "Accelerator"},
+    {ProcessorType::Core, "Core"},
+    {ProcessorType::Thread, "Thread"},
+    {ProcessorType::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ProcessorMemoryType, {
+    {ProcessorMemoryType::Invalid, "Invalid"},
+    {ProcessorMemoryType::L1Cache, "L1Cache"},
+    {ProcessorMemoryType::L2Cache, "L2Cache"},
+    {ProcessorMemoryType::L3Cache, "L3Cache"},
+    {ProcessorMemoryType::L4Cache, "L4Cache"},
+    {ProcessorMemoryType::L5Cache, "L5Cache"},
+    {ProcessorMemoryType::L6Cache, "L6Cache"},
+    {ProcessorMemoryType::L7Cache, "L7Cache"},
+    {ProcessorMemoryType::HBM1, "HBM1"},
+    {ProcessorMemoryType::HBM2, "HBM2"},
+    {ProcessorMemoryType::HBM3, "HBM3"},
+    {ProcessorMemoryType::SGRAM, "SGRAM"},
+    {ProcessorMemoryType::GDDR, "GDDR"},
+    {ProcessorMemoryType::GDDR2, "GDDR2"},
+    {ProcessorMemoryType::GDDR3, "GDDR3"},
+    {ProcessorMemoryType::GDDR4, "GDDR4"},
+    {ProcessorMemoryType::GDDR5, "GDDR5"},
+    {ProcessorMemoryType::GDDR5X, "GDDR5X"},
+    {ProcessorMemoryType::GDDR6, "GDDR6"},
+    {ProcessorMemoryType::DDR, "DDR"},
+    {ProcessorMemoryType::DDR2, "DDR2"},
+    {ProcessorMemoryType::DDR3, "DDR3"},
+    {ProcessorMemoryType::DDR4, "DDR4"},
+    {ProcessorMemoryType::DDR5, "DDR5"},
+    {ProcessorMemoryType::SDRAM, "SDRAM"},
+    {ProcessorMemoryType::SRAM, "SRAM"},
+    {ProcessorMemoryType::Flash, "Flash"},
+    {ProcessorMemoryType::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(FpgaType, {
+    {FpgaType::Invalid, "Invalid"},
+    {FpgaType::Integrated, "Integrated"},
+    {FpgaType::Discrete, "Discrete"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SystemInterfaceType, {
+    {SystemInterfaceType::Invalid, "Invalid"},
+    {SystemInterfaceType::QPI, "QPI"},
+    {SystemInterfaceType::UPI, "UPI"},
+    {SystemInterfaceType::PCIe, "PCIe"},
+    {SystemInterfaceType::Ethernet, "Ethernet"},
+    {SystemInterfaceType::AMBA, "AMBA"},
+    {SystemInterfaceType::CCIX, "CCIX"},
+    {SystemInterfaceType::CXL, "CXL"},
+    {SystemInterfaceType::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(TurboState, {
+    {TurboState::Invalid, "Invalid"},
+    {TurboState::Enabled, "Enabled"},
+    {TurboState::Disabled, "Disabled"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(BaseSpeedPriorityState, {
+    {BaseSpeedPriorityState::Invalid, "Invalid"},
+    {BaseSpeedPriorityState::Enabled, "Enabled"},
+    {BaseSpeedPriorityState::Disabled, "Disabled"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ThrottleCause, {
+    {ThrottleCause::Invalid, "Invalid"},
+    {ThrottleCause::PowerLimit, "PowerLimit"},
+    {ThrottleCause::ThermalLimit, "ThermalLimit"},
+    {ThrottleCause::ClockLimit, "ClockLimit"},
+    {ThrottleCause::Unknown, "Unknown"},
+    {ThrottleCause::OEM, "OEM"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/redfish_extensions.hpp b/redfish-core/include/generated/enums/redfish_extensions.hpp
new file mode 100644
index 0000000..c4cefcd
--- /dev/null
+++ b/redfish-core/include/generated/enums/redfish_extensions.hpp
@@ -0,0 +1,39 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace redfish_extensions
+{
+// clang-format off
+
+enum class ReleaseStatusType{
+    Invalid,
+    Standard,
+    Informational,
+    WorkInProgress,
+    InDevelopment,
+};
+
+enum class RevisionKind{
+    Invalid,
+    Added,
+    Modified,
+    Deprecated,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ReleaseStatusType, {
+    {ReleaseStatusType::Invalid, "Invalid"},
+    {ReleaseStatusType::Standard, "Standard"},
+    {ReleaseStatusType::Informational, "Informational"},
+    {ReleaseStatusType::WorkInProgress, "WorkInProgress"},
+    {ReleaseStatusType::InDevelopment, "InDevelopment"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(RevisionKind, {
+    {RevisionKind::Invalid, "Invalid"},
+    {RevisionKind::Added, "Added"},
+    {RevisionKind::Modified, "Modified"},
+    {RevisionKind::Deprecated, "Deprecated"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/redundancy.hpp b/redfish-core/include/generated/enums/redundancy.hpp
new file mode 100644
index 0000000..c894df5
--- /dev/null
+++ b/redfish-core/include/generated/enums/redundancy.hpp
@@ -0,0 +1,27 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace redundancy
+{
+// clang-format off
+
+enum class RedundancyType{
+    Invalid,
+    Failover,
+    NPlusM,
+    Sharing,
+    Sparing,
+    NotRedundant,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(RedundancyType, {
+    {RedundancyType::Invalid, "Invalid"},
+    {RedundancyType::Failover, "Failover"},
+    {RedundancyType::NPlusM, "NPlusM"},
+    {RedundancyType::Sharing, "Sharing"},
+    {RedundancyType::Sparing, "Sparing"},
+    {RedundancyType::NotRedundant, "NotRedundant"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/resource.hpp b/redfish-core/include/generated/enums/resource.hpp
new file mode 100644
index 0000000..76dbe16
--- /dev/null
+++ b/redfish-core/include/generated/enums/resource.hpp
@@ -0,0 +1,219 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace resource
+{
+// clang-format off
+
+enum class State{
+    Invalid,
+    Enabled,
+    Disabled,
+    StandbyOffline,
+    StandbySpare,
+    InTest,
+    Starting,
+    Absent,
+    UnavailableOffline,
+    Deferring,
+    Quiesced,
+    Updating,
+    Qualified,
+};
+
+enum class Health{
+    Invalid,
+    OK,
+    Warning,
+    Critical,
+};
+
+enum class ResetType{
+    Invalid,
+    On,
+    ForceOff,
+    GracefulShutdown,
+    GracefulRestart,
+    ForceRestart,
+    Nmi,
+    ForceOn,
+    PushPowerButton,
+    PowerCycle,
+    Suspend,
+    Pause,
+    Resume,
+};
+
+enum class IndicatorLED{
+    Invalid,
+    Lit,
+    Blinking,
+    Off,
+};
+
+enum class PowerState{
+    Invalid,
+    On,
+    Off,
+    PoweringOn,
+    PoweringOff,
+    Paused,
+};
+
+enum class DurableNameFormat{
+    Invalid,
+    NAA,
+    iQN,
+    FC_WWN,
+    UUID,
+    EUI,
+    NQN,
+    NSID,
+    NGUID,
+    MACAddress,
+};
+
+enum class RackUnits{
+    Invalid,
+    OpenU,
+    EIA_310,
+};
+
+enum class LocationType{
+    Invalid,
+    Slot,
+    Bay,
+    Connector,
+    Socket,
+    Backplane,
+    Embedded,
+};
+
+enum class Reference{
+    Invalid,
+    Top,
+    Bottom,
+    Front,
+    Rear,
+    Left,
+    Right,
+    Middle,
+};
+
+enum class Orientation{
+    Invalid,
+    FrontToBack,
+    BackToFront,
+    TopToBottom,
+    BottomToTop,
+    LeftToRight,
+    RightToLeft,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(State, {
+    {State::Invalid, "Invalid"},
+    {State::Enabled, "Enabled"},
+    {State::Disabled, "Disabled"},
+    {State::StandbyOffline, "StandbyOffline"},
+    {State::StandbySpare, "StandbySpare"},
+    {State::InTest, "InTest"},
+    {State::Starting, "Starting"},
+    {State::Absent, "Absent"},
+    {State::UnavailableOffline, "UnavailableOffline"},
+    {State::Deferring, "Deferring"},
+    {State::Quiesced, "Quiesced"},
+    {State::Updating, "Updating"},
+    {State::Qualified, "Qualified"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(Health, {
+    {Health::Invalid, "Invalid"},
+    {Health::OK, "OK"},
+    {Health::Warning, "Warning"},
+    {Health::Critical, "Critical"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ResetType, {
+    {ResetType::Invalid, "Invalid"},
+    {ResetType::On, "On"},
+    {ResetType::ForceOff, "ForceOff"},
+    {ResetType::GracefulShutdown, "GracefulShutdown"},
+    {ResetType::GracefulRestart, "GracefulRestart"},
+    {ResetType::ForceRestart, "ForceRestart"},
+    {ResetType::Nmi, "Nmi"},
+    {ResetType::ForceOn, "ForceOn"},
+    {ResetType::PushPowerButton, "PushPowerButton"},
+    {ResetType::PowerCycle, "PowerCycle"},
+    {ResetType::Suspend, "Suspend"},
+    {ResetType::Pause, "Pause"},
+    {ResetType::Resume, "Resume"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(IndicatorLED, {
+    {IndicatorLED::Invalid, "Invalid"},
+    {IndicatorLED::Lit, "Lit"},
+    {IndicatorLED::Blinking, "Blinking"},
+    {IndicatorLED::Off, "Off"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(PowerState, {
+    {PowerState::Invalid, "Invalid"},
+    {PowerState::On, "On"},
+    {PowerState::Off, "Off"},
+    {PowerState::PoweringOn, "PoweringOn"},
+    {PowerState::PoweringOff, "PoweringOff"},
+    {PowerState::Paused, "Paused"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(DurableNameFormat, {
+    {DurableNameFormat::Invalid, "Invalid"},
+    {DurableNameFormat::NAA, "NAA"},
+    {DurableNameFormat::iQN, "iQN"},
+    {DurableNameFormat::FC_WWN, "FC_WWN"},
+    {DurableNameFormat::UUID, "UUID"},
+    {DurableNameFormat::EUI, "EUI"},
+    {DurableNameFormat::NQN, "NQN"},
+    {DurableNameFormat::NSID, "NSID"},
+    {DurableNameFormat::NGUID, "NGUID"},
+    {DurableNameFormat::MACAddress, "MACAddress"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(RackUnits, {
+    {RackUnits::Invalid, "Invalid"},
+    {RackUnits::OpenU, "OpenU"},
+    {RackUnits::EIA_310, "EIA_310"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(LocationType, {
+    {LocationType::Invalid, "Invalid"},
+    {LocationType::Slot, "Slot"},
+    {LocationType::Bay, "Bay"},
+    {LocationType::Connector, "Connector"},
+    {LocationType::Socket, "Socket"},
+    {LocationType::Backplane, "Backplane"},
+    {LocationType::Embedded, "Embedded"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(Reference, {
+    {Reference::Invalid, "Invalid"},
+    {Reference::Top, "Top"},
+    {Reference::Bottom, "Bottom"},
+    {Reference::Front, "Front"},
+    {Reference::Rear, "Rear"},
+    {Reference::Left, "Left"},
+    {Reference::Right, "Right"},
+    {Reference::Middle, "Middle"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(Orientation, {
+    {Orientation::Invalid, "Invalid"},
+    {Orientation::FrontToBack, "FrontToBack"},
+    {Orientation::BackToFront, "BackToFront"},
+    {Orientation::TopToBottom, "TopToBottom"},
+    {Orientation::BottomToTop, "BottomToTop"},
+    {Orientation::LeftToRight, "LeftToRight"},
+    {Orientation::RightToLeft, "RightToLeft"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/sensor.hpp b/redfish-core/include/generated/enums/sensor.hpp
new file mode 100644
index 0000000..2f43e10
--- /dev/null
+++ b/redfish-core/include/generated/enums/sensor.hpp
@@ -0,0 +1,139 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace sensor
+{
+// clang-format off
+
+enum class VoltageType{
+    Invalid,
+    AC,
+    DC,
+};
+
+enum class ElectricalContext{
+    Invalid,
+    Line1,
+    Line2,
+    Line3,
+    Neutral,
+    LineToLine,
+    Line1ToLine2,
+    Line2ToLine3,
+    Line3ToLine1,
+    LineToNeutral,
+    Line1ToNeutral,
+    Line2ToNeutral,
+    Line3ToNeutral,
+    Line1ToNeutralAndL1L2,
+    Line2ToNeutralAndL1L2,
+    Line2ToNeutralAndL2L3,
+    Line3ToNeutralAndL3L1,
+    Total,
+};
+
+enum class ThresholdActivation{
+    Invalid,
+    Increasing,
+    Decreasing,
+    Either,
+};
+
+enum class ReadingType{
+    Invalid,
+    Temperature,
+    Humidity,
+    Power,
+    EnergykWh,
+    EnergyJoules,
+    EnergyWh,
+    ChargeAh,
+    Voltage,
+    Current,
+    Frequency,
+    Pressure,
+    PressurekPa,
+    LiquidLevel,
+    Rotational,
+    AirFlow,
+    LiquidFlow,
+    Barometric,
+    Altitude,
+    Percent,
+    AbsoluteHumidity,
+};
+
+enum class ImplementationType{
+    Invalid,
+    PhysicalSensor,
+    Synthesized,
+    Reported,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(VoltageType, {
+    {VoltageType::Invalid, "Invalid"},
+    {VoltageType::AC, "AC"},
+    {VoltageType::DC, "DC"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ElectricalContext, {
+    {ElectricalContext::Invalid, "Invalid"},
+    {ElectricalContext::Line1, "Line1"},
+    {ElectricalContext::Line2, "Line2"},
+    {ElectricalContext::Line3, "Line3"},
+    {ElectricalContext::Neutral, "Neutral"},
+    {ElectricalContext::LineToLine, "LineToLine"},
+    {ElectricalContext::Line1ToLine2, "Line1ToLine2"},
+    {ElectricalContext::Line2ToLine3, "Line2ToLine3"},
+    {ElectricalContext::Line3ToLine1, "Line3ToLine1"},
+    {ElectricalContext::LineToNeutral, "LineToNeutral"},
+    {ElectricalContext::Line1ToNeutral, "Line1ToNeutral"},
+    {ElectricalContext::Line2ToNeutral, "Line2ToNeutral"},
+    {ElectricalContext::Line3ToNeutral, "Line3ToNeutral"},
+    {ElectricalContext::Line1ToNeutralAndL1L2, "Line1ToNeutralAndL1L2"},
+    {ElectricalContext::Line2ToNeutralAndL1L2, "Line2ToNeutralAndL1L2"},
+    {ElectricalContext::Line2ToNeutralAndL2L3, "Line2ToNeutralAndL2L3"},
+    {ElectricalContext::Line3ToNeutralAndL3L1, "Line3ToNeutralAndL3L1"},
+    {ElectricalContext::Total, "Total"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ThresholdActivation, {
+    {ThresholdActivation::Invalid, "Invalid"},
+    {ThresholdActivation::Increasing, "Increasing"},
+    {ThresholdActivation::Decreasing, "Decreasing"},
+    {ThresholdActivation::Either, "Either"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ReadingType, {
+    {ReadingType::Invalid, "Invalid"},
+    {ReadingType::Temperature, "Temperature"},
+    {ReadingType::Humidity, "Humidity"},
+    {ReadingType::Power, "Power"},
+    {ReadingType::EnergykWh, "EnergykWh"},
+    {ReadingType::EnergyJoules, "EnergyJoules"},
+    {ReadingType::EnergyWh, "EnergyWh"},
+    {ReadingType::ChargeAh, "ChargeAh"},
+    {ReadingType::Voltage, "Voltage"},
+    {ReadingType::Current, "Current"},
+    {ReadingType::Frequency, "Frequency"},
+    {ReadingType::Pressure, "Pressure"},
+    {ReadingType::PressurekPa, "PressurekPa"},
+    {ReadingType::LiquidLevel, "LiquidLevel"},
+    {ReadingType::Rotational, "Rotational"},
+    {ReadingType::AirFlow, "AirFlow"},
+    {ReadingType::LiquidFlow, "LiquidFlow"},
+    {ReadingType::Barometric, "Barometric"},
+    {ReadingType::Altitude, "Altitude"},
+    {ReadingType::Percent, "Percent"},
+    {ReadingType::AbsoluteHumidity, "AbsoluteHumidity"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ImplementationType, {
+    {ImplementationType::Invalid, "Invalid"},
+    {ImplementationType::PhysicalSensor, "PhysicalSensor"},
+    {ImplementationType::Synthesized, "Synthesized"},
+    {ImplementationType::Reported, "Reported"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/session.hpp b/redfish-core/include/generated/enums/session.hpp
new file mode 100644
index 0000000..61da667
--- /dev/null
+++ b/redfish-core/include/generated/enums/session.hpp
@@ -0,0 +1,33 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace session
+{
+// clang-format off
+
+enum class SessionTypes{
+    Invalid,
+    HostConsole,
+    ManagerConsole,
+    IPMI,
+    KVMIP,
+    OEM,
+    Redfish,
+    VirtualMedia,
+    WebUI,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(SessionTypes, {
+    {SessionTypes::Invalid, "Invalid"},
+    {SessionTypes::HostConsole, "HostConsole"},
+    {SessionTypes::ManagerConsole, "ManagerConsole"},
+    {SessionTypes::IPMI, "IPMI"},
+    {SessionTypes::KVMIP, "KVMIP"},
+    {SessionTypes::OEM, "OEM"},
+    {SessionTypes::Redfish, "Redfish"},
+    {SessionTypes::VirtualMedia, "VirtualMedia"},
+    {SessionTypes::WebUI, "WebUI"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/settings.hpp b/redfish-core/include/generated/enums/settings.hpp
new file mode 100644
index 0000000..abd6922
--- /dev/null
+++ b/redfish-core/include/generated/enums/settings.hpp
@@ -0,0 +1,43 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace settings
+{
+// clang-format off
+
+enum class OperationApplyTime{
+    Invalid,
+    Immediate,
+    OnReset,
+    AtMaintenanceWindowStart,
+    InMaintenanceWindowOnReset,
+    OnStartUpdateRequest,
+};
+
+enum class ApplyTime{
+    Invalid,
+    Immediate,
+    OnReset,
+    AtMaintenanceWindowStart,
+    InMaintenanceWindowOnReset,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(OperationApplyTime, {
+    {OperationApplyTime::Invalid, "Invalid"},
+    {OperationApplyTime::Immediate, "Immediate"},
+    {OperationApplyTime::OnReset, "OnReset"},
+    {OperationApplyTime::AtMaintenanceWindowStart, "AtMaintenanceWindowStart"},
+    {OperationApplyTime::InMaintenanceWindowOnReset, "InMaintenanceWindowOnReset"},
+    {OperationApplyTime::OnStartUpdateRequest, "OnStartUpdateRequest"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ApplyTime, {
+    {ApplyTime::Invalid, "Invalid"},
+    {ApplyTime::Immediate, "Immediate"},
+    {ApplyTime::OnReset, "OnReset"},
+    {ApplyTime::AtMaintenanceWindowStart, "AtMaintenanceWindowStart"},
+    {ApplyTime::InMaintenanceWindowOnReset, "InMaintenanceWindowOnReset"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/storage.hpp b/redfish-core/include/generated/enums/storage.hpp
new file mode 100644
index 0000000..b9014ca
--- /dev/null
+++ b/redfish-core/include/generated/enums/storage.hpp
@@ -0,0 +1,21 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace storage
+{
+// clang-format off
+
+enum class ResetToDefaultsType{
+    Invalid,
+    ResetAll,
+    PreserveVolumes,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ResetToDefaultsType, {
+    {ResetToDefaultsType::Invalid, "Invalid"},
+    {ResetToDefaultsType::ResetAll, "ResetAll"},
+    {ResetToDefaultsType::PreserveVolumes, "PreserveVolumes"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/storage_controller.hpp b/redfish-core/include/generated/enums/storage_controller.hpp
new file mode 100644
index 0000000..78fca44
--- /dev/null
+++ b/redfish-core/include/generated/enums/storage_controller.hpp
@@ -0,0 +1,39 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace storage_controller
+{
+// clang-format off
+
+enum class NVMeControllerType{
+    Invalid,
+    Admin,
+    Discovery,
+    IO,
+};
+
+enum class ANAAccessState{
+    Invalid,
+    Optimized,
+    NonOptimized,
+    Inaccessible,
+    PersistentLoss,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(NVMeControllerType, {
+    {NVMeControllerType::Invalid, "Invalid"},
+    {NVMeControllerType::Admin, "Admin"},
+    {NVMeControllerType::Discovery, "Discovery"},
+    {NVMeControllerType::IO, "IO"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ANAAccessState, {
+    {ANAAccessState::Invalid, "Invalid"},
+    {ANAAccessState::Optimized, "Optimized"},
+    {ANAAccessState::NonOptimized, "NonOptimized"},
+    {ANAAccessState::Inaccessible, "Inaccessible"},
+    {ANAAccessState::PersistentLoss, "PersistentLoss"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/task.hpp b/redfish-core/include/generated/enums/task.hpp
new file mode 100644
index 0000000..2ef026f
--- /dev/null
+++ b/redfish-core/include/generated/enums/task.hpp
@@ -0,0 +1,43 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace task
+{
+// clang-format off
+
+enum class TaskState{
+    Invalid,
+    New,
+    Starting,
+    Running,
+    Suspended,
+    Interrupted,
+    Pending,
+    Stopping,
+    Completed,
+    Killed,
+    Exception,
+    Service,
+    Cancelling,
+    Cancelled,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(TaskState, {
+    {TaskState::Invalid, "Invalid"},
+    {TaskState::New, "New"},
+    {TaskState::Starting, "Starting"},
+    {TaskState::Running, "Running"},
+    {TaskState::Suspended, "Suspended"},
+    {TaskState::Interrupted, "Interrupted"},
+    {TaskState::Pending, "Pending"},
+    {TaskState::Stopping, "Stopping"},
+    {TaskState::Completed, "Completed"},
+    {TaskState::Killed, "Killed"},
+    {TaskState::Exception, "Exception"},
+    {TaskState::Service, "Service"},
+    {TaskState::Cancelling, "Cancelling"},
+    {TaskState::Cancelled, "Cancelled"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/task_service.hpp b/redfish-core/include/generated/enums/task_service.hpp
new file mode 100644
index 0000000..5e9a5cb
--- /dev/null
+++ b/redfish-core/include/generated/enums/task_service.hpp
@@ -0,0 +1,21 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace task_service
+{
+// clang-format off
+
+enum class OverWritePolicy{
+    Invalid,
+    Manual,
+    Oldest,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(OverWritePolicy, {
+    {OverWritePolicy::Invalid, "Invalid"},
+    {OverWritePolicy::Manual, "Manual"},
+    {OverWritePolicy::Oldest, "Oldest"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/telemetry_service.hpp b/redfish-core/include/generated/enums/telemetry_service.hpp
new file mode 100644
index 0000000..9e8cb0b
--- /dev/null
+++ b/redfish-core/include/generated/enums/telemetry_service.hpp
@@ -0,0 +1,25 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace telemetry_service
+{
+// clang-format off
+
+enum class CollectionFunction{
+    Invalid,
+    Average,
+    Maximum,
+    Minimum,
+    Summation,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(CollectionFunction, {
+    {CollectionFunction::Invalid, "Invalid"},
+    {CollectionFunction::Average, "Average"},
+    {CollectionFunction::Maximum, "Maximum"},
+    {CollectionFunction::Minimum, "Minimum"},
+    {CollectionFunction::Summation, "Summation"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/thermal.hpp b/redfish-core/include/generated/enums/thermal.hpp
new file mode 100644
index 0000000..50b624e
--- /dev/null
+++ b/redfish-core/include/generated/enums/thermal.hpp
@@ -0,0 +1,21 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace thermal
+{
+// clang-format off
+
+enum class ReadingUnits{
+    Invalid,
+    RPM,
+    Percent,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ReadingUnits, {
+    {ReadingUnits::Invalid, "Invalid"},
+    {ReadingUnits::RPM, "RPM"},
+    {ReadingUnits::Percent, "Percent"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/triggers.hpp b/redfish-core/include/generated/enums/triggers.hpp
new file mode 100644
index 0000000..b272057
--- /dev/null
+++ b/redfish-core/include/generated/enums/triggers.hpp
@@ -0,0 +1,73 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace triggers
+{
+// clang-format off
+
+enum class MetricTypeEnum{
+    Invalid,
+    Numeric,
+    Discrete,
+};
+
+enum class TriggerActionEnum{
+    Invalid,
+    LogToLogService,
+    RedfishEvent,
+    RedfishMetricReport,
+};
+
+enum class DiscreteTriggerConditionEnum{
+    Invalid,
+    Specified,
+    Changed,
+};
+
+enum class ThresholdActivation{
+    Invalid,
+    Increasing,
+    Decreasing,
+    Either,
+};
+
+enum class DirectionOfCrossingEnum{
+    Invalid,
+    Increasing,
+    Decreasing,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MetricTypeEnum, {
+    {MetricTypeEnum::Invalid, "Invalid"},
+    {MetricTypeEnum::Numeric, "Numeric"},
+    {MetricTypeEnum::Discrete, "Discrete"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(TriggerActionEnum, {
+    {TriggerActionEnum::Invalid, "Invalid"},
+    {TriggerActionEnum::LogToLogService, "LogToLogService"},
+    {TriggerActionEnum::RedfishEvent, "RedfishEvent"},
+    {TriggerActionEnum::RedfishMetricReport, "RedfishMetricReport"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(DiscreteTriggerConditionEnum, {
+    {DiscreteTriggerConditionEnum::Invalid, "Invalid"},
+    {DiscreteTriggerConditionEnum::Specified, "Specified"},
+    {DiscreteTriggerConditionEnum::Changed, "Changed"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ThresholdActivation, {
+    {ThresholdActivation::Invalid, "Invalid"},
+    {ThresholdActivation::Increasing, "Increasing"},
+    {ThresholdActivation::Decreasing, "Decreasing"},
+    {ThresholdActivation::Either, "Either"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(DirectionOfCrossingEnum, {
+    {DirectionOfCrossingEnum::Invalid, "Invalid"},
+    {DirectionOfCrossingEnum::Increasing, "Increasing"},
+    {DirectionOfCrossingEnum::Decreasing, "Decreasing"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/update_service.hpp b/redfish-core/include/generated/enums/update_service.hpp
new file mode 100644
index 0000000..0a1e477
--- /dev/null
+++ b/redfish-core/include/generated/enums/update_service.hpp
@@ -0,0 +1,55 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace update_service
+{
+// clang-format off
+
+enum class TransferProtocolType{
+    Invalid,
+    CIFS,
+    FTP,
+    SFTP,
+    HTTP,
+    HTTPS,
+    NSF,
+    SCP,
+    TFTP,
+    OEM,
+    NFS,
+};
+
+enum class ApplyTime{
+    Invalid,
+    Immediate,
+    OnReset,
+    AtMaintenanceWindowStart,
+    InMaintenanceWindowOnReset,
+    OnStartUpdateRequest,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(TransferProtocolType, {
+    {TransferProtocolType::Invalid, "Invalid"},
+    {TransferProtocolType::CIFS, "CIFS"},
+    {TransferProtocolType::FTP, "FTP"},
+    {TransferProtocolType::SFTP, "SFTP"},
+    {TransferProtocolType::HTTP, "HTTP"},
+    {TransferProtocolType::HTTPS, "HTTPS"},
+    {TransferProtocolType::NSF, "NSF"},
+    {TransferProtocolType::SCP, "SCP"},
+    {TransferProtocolType::TFTP, "TFTP"},
+    {TransferProtocolType::OEM, "OEM"},
+    {TransferProtocolType::NFS, "NFS"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ApplyTime, {
+    {ApplyTime::Invalid, "Invalid"},
+    {ApplyTime::Immediate, "Immediate"},
+    {ApplyTime::OnReset, "OnReset"},
+    {ApplyTime::AtMaintenanceWindowStart, "AtMaintenanceWindowStart"},
+    {ApplyTime::InMaintenanceWindowOnReset, "InMaintenanceWindowOnReset"},
+    {ApplyTime::OnStartUpdateRequest, "OnStartUpdateRequest"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/generated/enums/virtual_media.hpp b/redfish-core/include/generated/enums/virtual_media.hpp
new file mode 100644
index 0000000..3f9fc78
--- /dev/null
+++ b/redfish-core/include/generated/enums/virtual_media.hpp
@@ -0,0 +1,79 @@
+#pragma once
+#include <nlohmann/json.hpp>
+
+namespace virtual_media
+{
+// clang-format off
+
+enum class MediaType{
+    Invalid,
+    CD,
+    Floppy,
+    USBStick,
+    DVD,
+};
+
+enum class ConnectedVia{
+    Invalid,
+    NotConnected,
+    URI,
+    Applet,
+    Oem,
+};
+
+enum class TransferProtocolType{
+    Invalid,
+    CIFS,
+    FTP,
+    SFTP,
+    HTTP,
+    HTTPS,
+    NFS,
+    SCP,
+    TFTP,
+    OEM,
+};
+
+enum class TransferMethod{
+    Invalid,
+    Stream,
+    Upload,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(MediaType, {
+    {MediaType::Invalid, "Invalid"},
+    {MediaType::CD, "CD"},
+    {MediaType::Floppy, "Floppy"},
+    {MediaType::USBStick, "USBStick"},
+    {MediaType::DVD, "DVD"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(ConnectedVia, {
+    {ConnectedVia::Invalid, "Invalid"},
+    {ConnectedVia::NotConnected, "NotConnected"},
+    {ConnectedVia::URI, "URI"},
+    {ConnectedVia::Applet, "Applet"},
+    {ConnectedVia::Oem, "Oem"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(TransferProtocolType, {
+    {TransferProtocolType::Invalid, "Invalid"},
+    {TransferProtocolType::CIFS, "CIFS"},
+    {TransferProtocolType::FTP, "FTP"},
+    {TransferProtocolType::SFTP, "SFTP"},
+    {TransferProtocolType::HTTP, "HTTP"},
+    {TransferProtocolType::HTTPS, "HTTPS"},
+    {TransferProtocolType::NFS, "NFS"},
+    {TransferProtocolType::SCP, "SCP"},
+    {TransferProtocolType::TFTP, "TFTP"},
+    {TransferProtocolType::OEM, "OEM"},
+});
+
+NLOHMANN_JSON_SERIALIZE_ENUM(TransferMethod, {
+    {TransferMethod::Invalid, "Invalid"},
+    {TransferMethod::Stream, "Stream"},
+    {TransferMethod::Upload, "Upload"},
+});
+
+}
+// clang-format on
diff --git a/redfish-core/include/utils/sw_utils.hpp b/redfish-core/include/utils/sw_utils.hpp
index c66bff8..e2b90ca 100644
--- a/redfish-core/include/utils/sw_utils.hpp
+++ b/redfish-core/include/utils/sw_utils.hpp
@@ -1,6 +1,7 @@
 #pragma once
 #include <async_resp.hpp>
 #include <dbus_utility.hpp>
+#include <generated/enums/resource.hpp>
 #include <sdbusplus/asio/property.hpp>
 #include <sdbusplus/unpack_properties.hpp>
 #include <utils/dbus_utils.hpp>
@@ -234,24 +235,24 @@
  *
  * @return The corresponding Redfish state
  */
-inline std::string getRedfishSwState(const std::string& swState)
+inline resource::State getRedfishSwState(const std::string& swState)
 {
     if (swState == "xyz.openbmc_project.Software.Activation.Activations.Active")
     {
-        return "Enabled";
+        return resource::State::Enabled;
     }
     if (swState == "xyz.openbmc_project.Software.Activation."
                    "Activations.Activating")
     {
-        return "Updating";
+        return resource::State::Updating;
     }
     if (swState == "xyz.openbmc_project.Software.Activation."
                    "Activations.StandbySpare")
     {
-        return "StandbySpare";
+        return resource::State::StandbySpare;
     }
     BMCWEB_LOG_DEBUG << "Default sw state " << swState << " to Disabled";
-    return "Disabled";
+    return resource::State::Disabled;
 }
 
 /**
diff --git a/redfish-core/lib/account_service.hpp b/redfish-core/lib/account_service.hpp
index 8ccab65..3a8ffbc 100644
--- a/redfish-core/lib/account_service.hpp
+++ b/redfish-core/lib/account_service.hpp
@@ -15,13 +15,15 @@
 */
 #pragma once
 
+#include "generated/enums/account_service.hpp"
+#include "registries/privilege_registry.hpp"
+
 #include <app.hpp>
 #include <dbus_utility.hpp>
 #include <error_messages.hpp>
 #include <openbmc_dbus_rest.hpp>
 #include <persistent_data.hpp>
 #include <query.hpp>
-#include <registries/privilege_registry.hpp>
 #include <sdbusplus/asio/property.hpp>
 #include <sdbusplus/unpack_properties.hpp>
 #include <utils/dbus_utils.hpp>
@@ -210,7 +212,8 @@
 
     ldap["ServiceEnabled"] = confData.serviceEnabled;
     ldap["ServiceAddresses"] = nlohmann::json::array({confData.uri});
-    ldap["Authentication"]["AuthenticationType"] = "UsernameAndPassword";
+    ldap["Authentication"]["AuthenticationType"] =
+        account_service::AuthenticationTypes::UsernameAndPassword;
     ldap["Authentication"]["Username"] = confData.bindDN;
     ldap["Authentication"]["Password"] = nullptr;
 
diff --git a/redfish-core/lib/pcie.hpp b/redfish-core/lib/pcie.hpp
index ebbf926..8af9580 100644
--- a/redfish-core/lib/pcie.hpp
+++ b/redfish-core/lib/pcie.hpp
@@ -16,6 +16,8 @@
 
 #pragma once
 
+#include "generated/enums/pcie_device.hpp"
+
 #include <app.hpp>
 #include <boost/system/linux_error.hpp>
 #include <dbus_utility.hpp>
@@ -111,39 +113,39 @@
         });
 }
 
-inline std::optional<std::string>
+inline std::optional<pcie_device::PCIeTypes>
     redfishPcieGenerationFromDbus(const std::string& generationInUse)
 {
     if (generationInUse ==
         "xyz.openbmc_project.Inventory.Item.PCIeSlot.Generations.Gen1")
     {
-        return "Gen1";
+        return pcie_device::PCIeTypes::Gen1;
     }
     if (generationInUse ==
         "xyz.openbmc_project.Inventory.Item.PCIeSlot.Generations.Gen2")
     {
-        return "Gen2";
+        return pcie_device::PCIeTypes::Gen2;
     }
     if (generationInUse ==
         "xyz.openbmc_project.Inventory.Item.PCIeSlot.Generations.Gen3")
     {
-        return "Gen3";
+        return pcie_device::PCIeTypes::Gen3;
     }
     if (generationInUse ==
         "xyz.openbmc_project.Inventory.Item.PCIeSlot.Generations.Gen4")
     {
-        return "Gen4";
+        return pcie_device::PCIeTypes::Gen4;
     }
     if (generationInUse ==
         "xyz.openbmc_project.Inventory.Item.PCIeSlot.Generations.Gen5")
     {
-        return "Gen5";
+        return pcie_device::PCIeTypes::Gen5;
     }
     if (generationInUse.empty() ||
         generationInUse ==
             "xyz.openbmc_project.Inventory.Item.PCIeSlot.Generations.Unknown")
     {
-        return "";
+        return pcie_device::PCIeTypes::Invalid;
     }
 
     // The value is not unknown or Gen1-5, need return an internal error.
@@ -208,14 +210,14 @@
 
             if (generationInUse != nullptr)
             {
-                std::optional<std::string> redfishGenerationInUse =
+                std::optional<pcie_device::PCIeTypes> redfishGenerationInUse =
                     redfishPcieGenerationFromDbus(*generationInUse);
                 if (!redfishGenerationInUse)
                 {
                     messages::internalError(asyncResp->res);
                     return;
                 }
-                if (!redfishGenerationInUse->empty())
+                if (*redfishGenerationInUse != pcie_device::PCIeTypes::Invalid)
                 {
                     asyncResp->res.jsonValue["PCIeInterface"]["PCIeType"] =
                         *redfishGenerationInUse;
diff --git a/redfish-core/lib/pcie_slots.hpp b/redfish-core/lib/pcie_slots.hpp
index 778768f..668987d 100644
--- a/redfish-core/lib/pcie_slots.hpp
+++ b/redfish-core/lib/pcie_slots.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "error_messages.hpp"
+#include "generated/enums/pcie_slot.hpp"
 #include "utility.hpp"
 
 #include <app.hpp>
@@ -14,53 +15,53 @@
 namespace redfish
 {
 
-inline std::string dbusSlotTypeToRf(const std::string& slotType)
+inline pcie_slot::SlotTypes dbusSlotTypeToRf(const std::string& slotType)
 {
     if (slotType ==
         "xyz.openbmc_project.Inventory.Item.PCIeSlot.SlotTypes.FullLength")
     {
-        return "FullLength";
+        return pcie_slot::SlotTypes::FullLength;
     }
     if (slotType ==
         "xyz.openbmc_project.Inventory.Item.PCIeSlot.SlotTypes.HalfLength")
     {
-        return "HalfLength";
+        return pcie_slot::SlotTypes::HalfLength;
     }
     if (slotType ==
         "xyz.openbmc_project.Inventory.Item.PCIeSlot.SlotTypes.LowProfile")
     {
-        return "LowProfile";
+        return pcie_slot::SlotTypes::LowProfile;
     }
     if (slotType ==
         "xyz.openbmc_project.Inventory.Item.PCIeSlot.SlotTypes.Mini")
     {
-        return "Mini";
+        return pcie_slot::SlotTypes::Mini;
     }
     if (slotType == "xyz.openbmc_project.Inventory.Item.PCIeSlot.SlotTypes.M_2")
     {
-        return "M2";
+        return pcie_slot::SlotTypes::M2;
     }
     if (slotType == "xyz.openbmc_project.Inventory.Item.PCIeSlot.SlotTypes.OEM")
     {
-        return "OEM";
+        return pcie_slot::SlotTypes::OEM;
     }
     if (slotType ==
         "xyz.openbmc_project.Inventory.Item.PCIeSlot.SlotTypes.OCP3Small")
     {
-        return "OCP3Small";
+        return pcie_slot::SlotTypes::OCP3Small;
     }
     if (slotType ==
         "xyz.openbmc_project.Inventory.Item.PCIeSlot.SlotTypes.OCP3Large")
     {
-        return "OCP3Large";
+        return pcie_slot::SlotTypes::OCP3Large;
     }
     if (slotType == "xyz.openbmc_project.Inventory.Item.PCIeSlot.SlotTypes.U_2")
     {
-        return "U2";
+        return pcie_slot::SlotTypes::U2;
     }
 
     // Unknown or others
-    return "";
+    return pcie_slot::SlotTypes::Invalid;
 }
 
 inline void
@@ -106,7 +107,7 @@
 
     if (generation != nullptr)
     {
-        std::optional<std::string> pcieType =
+        std::optional<pcie_device::PCIeTypes> pcieType =
             redfishPcieGenerationFromDbus(*generation);
         if (!pcieType)
         {
diff --git a/redfish-core/lib/sensors.hpp b/redfish-core/lib/sensors.hpp
index 390a2a7..5bbb642 100644
--- a/redfish-core/lib/sensors.hpp
+++ b/redfish-core/lib/sensors.hpp
@@ -15,6 +15,8 @@
 */
 #pragma once
 
+#include "generated/enums/sensor.hpp"
+
 #include <app.hpp>
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/find.hpp>
@@ -89,49 +91,49 @@
      {node::sensors, std::span<std::string_view>(dbus::sensorPaths)},
      {node::thermal, std::span<std::string_view>(dbus::thermalPaths)}}};
 
-inline std::string_view toReadingType(std::string_view sensorType)
+inline sensor::ReadingType toReadingType(std::string_view sensorType)
 {
     if (sensorType == "voltage")
     {
-        return "Voltage";
+        return sensor::ReadingType::Voltage;
     }
     if (sensorType == "power")
     {
-        return "Power";
+        return sensor::ReadingType::Power;
     }
     if (sensorType == "current")
     {
-        return "Current";
+        return sensor::ReadingType::Current;
     }
     if (sensorType == "fan_tach")
     {
-        return "Rotational";
+        return sensor::ReadingType::Rotational;
     }
     if (sensorType == "temperature")
     {
-        return "Temperature";
+        return sensor::ReadingType::Temperature;
     }
     if (sensorType == "fan_pwm" || sensorType == "utilization")
     {
-        return "Percent";
+        return sensor::ReadingType::Percent;
     }
     if (sensorType == "humidity")
     {
-        return "Humidity";
+        return sensor::ReadingType::Humidity;
     }
     if (sensorType == "altitude")
     {
-        return "Altitude";
+        return sensor::ReadingType::Altitude;
     }
     if (sensorType == "airflow")
     {
-        return "AirFlow";
+        return sensor::ReadingType::AirFlow;
     }
     if (sensorType == "energy")
     {
-        return "EnergyJoules";
+        return sensor::ReadingType::EnergyJoules;
     }
-    return "";
+    return sensor::ReadingType::Invalid;
 }
 
 inline std::string_view toReadingUnits(std::string_view sensorType)
@@ -842,8 +844,8 @@
     {
         sensorJson["@odata.type"] = "#Sensor.v1_2_0.Sensor";
 
-        std::string_view readingType = sensors::toReadingType(sensorType);
-        if (readingType.empty())
+        sensor::ReadingType readingType = sensors::toReadingType(sensorType);
+        if (readingType == sensor::ReadingType::Invalid)
         {
             BMCWEB_LOG_ERROR << "Redfish cannot map reading type for "
                              << sensorType;
diff --git a/scripts/generate_schema_enums.py b/scripts/generate_schema_enums.py
new file mode 100755
index 0000000..13fbefe
--- /dev/null
+++ b/scripts/generate_schema_enums.py
@@ -0,0 +1,163 @@
+#!/usr/bin/python3
+import os
+import xml.etree.ElementTree as ET
+from collections import defaultdict
+import shutil
+import re
+
+
+SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
+REDFISH_SCHEMA_DIR = os.path.realpath(
+    os.path.join(SCRIPT_DIR, "..", "static", "redfish", "v1", "schema")
+)
+
+OUTFOLDER = os.path.realpath(os.path.join(
+    SCRIPT_DIR,
+    "..",
+    "redfish-core",
+    "include",
+    "generated",
+    "enums"
+  )
+)
+
+# Odata string types
+EDMX = "{http://docs.oasis-open.org/odata/ns/edmx}"
+EDM = "{http://docs.oasis-open.org/odata/ns/edm}"
+
+
+class Enum:
+    def __init__(self, name, values, namespace, from_file):
+        self.name = name
+        self.values = values
+        self.namespace = namespace
+        self.from_file = from_file
+
+
+def parse_schema(element, filename):
+    EntityTypes = []
+    namespace = element.attrib["Namespace"]
+    for schema_element in element:
+        name = schema_element.attrib.get("Name", None)
+        if name is None:
+            continue
+        if schema_element.tag == EDM + "EnumType":
+            enums = []
+            for member in schema_element.findall(EDM + "Member"):
+                enums.append(member.attrib["Name"])
+            EntityTypes.append(Enum(name, enums, namespace, filename))
+    return EntityTypes
+
+
+def parse_file(filename):
+    tree = ET.parse(filename)
+    root = tree.getroot()
+    results = []
+    data_services = root.findall(EDMX + "DataServices")
+    for ds in data_services:
+        for element in ds:
+            if element.tag == EDM + "Schema":
+                results.extend(parse_schema(element, filename))
+
+    return results
+
+
+def camel_to_snake(name):
+    # snake casing PCIeDevice and PCIeFunction results in mediocre results
+    # given that the standard didn't camel case those in a way that the
+    # algorithm expects, so change the casing explicitly to generate sane
+    # snake case results.
+    name = name.replace("PCIe", "Pcie")
+    name = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
+    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", name).lower()
+
+
+def write_enum_list(redfish_defs_file, enum_list, snake_case_namespace):
+    redfish_defs_file.write(
+        "#pragma once\n"
+        "#include <nlohmann/json.hpp>\n\n"
+        "namespace {}\n"
+        "{{\n"
+        "// clang-format off\n\n".format(snake_case_namespace)
+    )
+
+    for element in enum_list:
+        redfish_defs_file.write("enum class {}{{\n".format(element.name))
+        values = element.values
+        if "Invalid" not in values:
+            values.insert(0, "Invalid")
+
+        for value in values:
+            redfish_defs_file.write("    {},\n".format(value))
+
+        redfish_defs_file.write("};\n\n")
+
+    for element in enum_list:
+        values = element.values
+        if "Invalid" not in values:
+            values.insert(0, "Invalid")
+        # nlohmann::json aparently uses c style arrays in their enum
+        # implementation, and clang-tidy isn't smart enough to figure out that
+        # the C arrays are in their code not bmcwebs, so we have to explicitly
+        # ignore the error.
+        redfish_defs_file.write(
+            "NLOHMANN_JSON_SERIALIZE_ENUM({}, {{\n".format(
+                element.name
+            )
+        )
+        for value in values:
+            redfish_defs_file.write(
+                '    {{{}::{}, "{}"}},\n'.format(element.name, value, value)
+            )
+
+        redfish_defs_file.write("});\n\n")
+
+        print(element.name)
+
+    redfish_defs_file.write("}\n" "// clang-format on\n")
+
+
+def generate_enums(flat_list):
+    # clear out the old results if they exist
+    if os.path.exists(OUTFOLDER):
+        shutil.rmtree(OUTFOLDER)
+    os.makedirs(OUTFOLDER)
+
+    enum_by_namespace = defaultdict(list)
+
+    for element in flat_list:
+        if isinstance(element, Enum):
+            namespace_split = element.namespace.split(".")[0]
+            enum_by_namespace[namespace_split].append(element)
+
+    for namespace, enum_list in enum_by_namespace.items():
+        snake_case_namespace = camel_to_snake(namespace)
+        outfile = os.path.join(
+            OUTFOLDER, "{}.hpp".format(snake_case_namespace)
+        )
+
+        with open(outfile, "w") as redfish_defs:
+            write_enum_list(redfish_defs, enum_list, snake_case_namespace)
+
+
+def main():
+    print("Reading from {}".format(REDFISH_SCHEMA_DIR))
+    dir_list = os.listdir(REDFISH_SCHEMA_DIR)
+
+    filepaths = [
+        os.path.join(REDFISH_SCHEMA_DIR, filename) for filename in dir_list
+    ]
+
+    enum_list = []
+
+    for filepath in filepaths:
+        out = parse_file(filepath)
+        enum_list.extend(out)
+
+    print("Parsing done")
+
+    generate_enums(enum_list)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/update_schemas.py b/scripts/update_schemas.py
index 459d045..f6eca42 100755
--- a/scripts/update_schemas.py
+++ b/scripts/update_schemas.py
@@ -8,6 +8,7 @@
 
 import requests
 from packaging.version import parse
+import generate_schema_enums
 
 VERSION = "DSP8010_2022.2"
 
@@ -390,3 +391,5 @@
     hpp_file.write("    };\n}\n")
 
 zip_ref.close()
+
+generate_schema_enums.main()