diff --git a/http/routing.hpp b/http/routing.hpp
index af6269e..d2a10b2 100644
--- a/http/routing.hpp
+++ b/http/routing.hpp
@@ -443,6 +443,17 @@
         }
         return *self;
     }
+
+    template <size_t N, typename... MethodArgs>
+    self_t& privileges(const std::array<redfish::Privileges, N>& p)
+    {
+        self_t* self = static_cast<self_t*>(this);
+        for (const redfish::Privileges& privilege : p)
+        {
+            self->privilegesSet.emplace_back(privilege);
+        }
+        return *self;
+    }
 };
 
 class DynamicRule : public BaseRule, public RuleParameterTraits<DynamicRule>
diff --git a/redfish-core/include/registries/privilege_registry.hpp b/redfish-core/include/registries/privilege_registry.hpp
new file mode 100644
index 0000000..706a24c
--- /dev/null
+++ b/redfish-core/include/registries/privilege_registry.hpp
@@ -0,0 +1,1342 @@
+#pragma once
+// privilege_registry.hpp is generated.  Do not edit directly
+#include <privileges.hpp>
+
+namespace redfish::privileges
+{
+// clang-format off
+const std::array<Privileges, 1> privilegeSetLogin = {{
+    {"Login"}
+}};
+const std::array<Privileges, 1> privilegeSetConfigureComponents = {{
+    {"ConfigureComponents"}
+}};
+const std::array<Privileges, 1> privilegeSetConfigureUsers = {{
+    {"ConfigureUsers"}
+}};
+const std::array<Privileges, 1> privilegeSetConfigureManager = {{
+    {"ConfigureManager"}
+}};
+const std::array<Privileges, 2> privilegeSetConfigureManagerOrConfigureComponents = {{
+    {"ConfigureManager"},
+    {"ConfigureComponents"}
+}};
+const std::array<Privileges, 2> privilegeSetConfigureManagerOrConfigureSelf = {{
+    {"ConfigureManager"},
+    {"ConfigureSelf"}
+}};
+const std::array<Privileges, 3> privilegeSetConfigureManagerOrConfigureUsersOrConfigureSelf = {{
+    {"ConfigureManager"},
+    {"ConfigureUsers"},
+    {"ConfigureSelf"}
+}};
+const std::array<Privileges, 2> privilegeSetLoginOrNoAuth = {{
+    {"Login"},
+    {}
+}};
+// clang-format on
+
+// AccelerationFunction
+const auto& getAccelerationFunction = privilegeSetLogin;
+const auto& headAccelerationFunction = privilegeSetLogin;
+const auto& patchAccelerationFunction = privilegeSetConfigureComponents;
+const auto& putAccelerationFunction = privilegeSetConfigureComponents;
+const auto& deleteAccelerationFunction = privilegeSetConfigureComponents;
+const auto& postAccelerationFunction = privilegeSetConfigureComponents;
+
+// AccelerationFunctionCollection
+const auto& getAccelerationFunctionCollection = privilegeSetLogin;
+const auto& headAccelerationFunctionCollection = privilegeSetLogin;
+const auto& patchAccelerationFunctionCollection =
+    privilegeSetConfigureComponents;
+const auto& putAccelerationFunctionCollection = privilegeSetConfigureComponents;
+const auto& deleteAccelerationFunctionCollection =
+    privilegeSetConfigureComponents;
+const auto& postAccelerationFunctionCollection =
+    privilegeSetConfigureComponents;
+
+// AccountService
+const auto& getAccountService = privilegeSetLogin;
+const auto& headAccountService = privilegeSetLogin;
+const auto& patchAccountService = privilegeSetConfigureUsers;
+const auto& putAccountService = privilegeSetConfigureUsers;
+const auto& deleteAccountService = privilegeSetConfigureUsers;
+const auto& postAccountService = privilegeSetConfigureUsers;
+
+// ActionInfo
+const auto& getActionInfo = privilegeSetLogin;
+const auto& headActionInfo = privilegeSetLogin;
+const auto& patchActionInfo = privilegeSetConfigureManager;
+const auto& putActionInfo = privilegeSetConfigureManager;
+const auto& deleteActionInfo = privilegeSetConfigureManager;
+const auto& postActionInfo = privilegeSetConfigureManager;
+
+// AddressPool
+const auto& getAddressPool = privilegeSetLogin;
+const auto& headAddressPool = privilegeSetLogin;
+const auto& patchAddressPool = privilegeSetConfigureComponents;
+const auto& putAddressPool = privilegeSetConfigureComponents;
+const auto& deleteAddressPool = privilegeSetConfigureComponents;
+const auto& postAddressPool = privilegeSetConfigureComponents;
+
+// AddressPoolCollection
+const auto& getAddressPoolCollection = privilegeSetLogin;
+const auto& headAddressPoolCollection = privilegeSetLogin;
+const auto& patchAddressPoolCollection = privilegeSetConfigureComponents;
+const auto& putAddressPoolCollection = privilegeSetConfigureComponents;
+const auto& deleteAddressPoolCollection = privilegeSetConfigureComponents;
+const auto& postAddressPoolCollection = privilegeSetConfigureComponents;
+
+// Aggregate
+const auto& getAggregate = privilegeSetLogin;
+const auto& headAggregate = privilegeSetLogin;
+const auto& patchAggregate = privilegeSetConfigureManagerOrConfigureComponents;
+const auto& putAggregate = privilegeSetConfigureManagerOrConfigureComponents;
+const auto& deleteAggregate = privilegeSetConfigureManagerOrConfigureComponents;
+const auto& postAggregate = privilegeSetConfigureManagerOrConfigureComponents;
+
+// AggregateCollection
+const auto& getAggregateCollection = privilegeSetLogin;
+const auto& headAggregateCollection = privilegeSetLogin;
+const auto& patchAggregateCollection =
+    privilegeSetConfigureManagerOrConfigureComponents;
+const auto& putAggregateCollection =
+    privilegeSetConfigureManagerOrConfigureComponents;
+const auto& deleteAggregateCollection =
+    privilegeSetConfigureManagerOrConfigureComponents;
+const auto& postAggregateCollection =
+    privilegeSetConfigureManagerOrConfigureComponents;
+
+// AggregationService
+const auto& getAggregationService = privilegeSetLogin;
+const auto& headAggregationService = privilegeSetLogin;
+const auto& patchAggregationService = privilegeSetConfigureManager;
+const auto& putAggregationService = privilegeSetConfigureManager;
+const auto& deleteAggregationService = privilegeSetConfigureManager;
+const auto& postAggregationService = privilegeSetConfigureManager;
+
+// AggregationSource
+const auto& getAggregationSource = privilegeSetLogin;
+const auto& headAggregationSource = privilegeSetLogin;
+const auto& patchAggregationSource = privilegeSetConfigureManager;
+const auto& putAggregationSource = privilegeSetConfigureManager;
+const auto& deleteAggregationSource = privilegeSetConfigureManager;
+const auto& postAggregationSource = privilegeSetConfigureManager;
+
+// AggregationSourceCollection
+const auto& getAggregationSourceCollection = privilegeSetLogin;
+const auto& headAggregationSourceCollection = privilegeSetLogin;
+const auto& patchAggregationSourceCollection = privilegeSetConfigureManager;
+const auto& putAggregationSourceCollection = privilegeSetConfigureManager;
+const auto& deleteAggregationSourceCollection = privilegeSetConfigureManager;
+const auto& postAggregationSourceCollection = privilegeSetConfigureManager;
+
+// Assembly
+const auto& getAssembly = privilegeSetLogin;
+const auto& headAssembly = privilegeSetLogin;
+const auto& patchAssembly = privilegeSetConfigureComponents;
+const auto& putAssembly = privilegeSetConfigureComponents;
+const auto& deleteAssembly = privilegeSetConfigureComponents;
+const auto& postAssembly = privilegeSetConfigureComponents;
+
+// Bios
+const auto& getBios = privilegeSetLogin;
+const auto& headBios = privilegeSetLogin;
+const auto& patchBios = privilegeSetConfigureComponents;
+const auto& postBios = privilegeSetConfigureComponents;
+const auto& putBios = privilegeSetConfigureComponents;
+const auto& deleteBios = privilegeSetConfigureComponents;
+
+// BootOption
+const auto& getBootOption = privilegeSetLogin;
+const auto& headBootOption = privilegeSetLogin;
+const auto& patchBootOption = privilegeSetConfigureComponents;
+const auto& putBootOption = privilegeSetConfigureComponents;
+const auto& deleteBootOption = privilegeSetConfigureComponents;
+const auto& postBootOption = privilegeSetConfigureComponents;
+
+// BootOptionCollection
+const auto& getBootOptionCollection = privilegeSetLogin;
+const auto& headBootOptionCollection = privilegeSetLogin;
+const auto& patchBootOptionCollection = privilegeSetConfigureComponents;
+const auto& putBootOptionCollection = privilegeSetConfigureComponents;
+const auto& deleteBootOptionCollection = privilegeSetConfigureComponents;
+const auto& postBootOptionCollection = privilegeSetConfigureComponents;
+
+// Certificate
+const auto& getCertificate = privilegeSetConfigureManager;
+const auto& headCertificate = privilegeSetConfigureManager;
+const auto& patchCertificate = privilegeSetConfigureManager;
+const auto& putCertificate = privilegeSetConfigureManager;
+const auto& deleteCertificate = privilegeSetConfigureManager;
+const auto& postCertificate = privilegeSetConfigureManager;
+
+// CertificateCollection
+const auto& getCertificateCollection = privilegeSetConfigureManager;
+const auto& headCertificateCollection = privilegeSetConfigureManager;
+const auto& patchCertificateCollection = privilegeSetConfigureManager;
+const auto& putCertificateCollection = privilegeSetConfigureManager;
+const auto& deleteCertificateCollection = privilegeSetConfigureManager;
+const auto& postCertificateCollection = privilegeSetConfigureManager;
+
+// CertificateLocations
+const auto& getCertificateLocations = privilegeSetConfigureManager;
+const auto& headCertificateLocations = privilegeSetConfigureManager;
+const auto& patchCertificateLocations = privilegeSetConfigureManager;
+const auto& putCertificateLocations = privilegeSetConfigureManager;
+const auto& deleteCertificateLocations = privilegeSetConfigureManager;
+const auto& postCertificateLocations = privilegeSetConfigureManager;
+
+// CertificateService
+const auto& getCertificateService = privilegeSetLogin;
+const auto& headCertificateService = privilegeSetLogin;
+const auto& patchCertificateService = privilegeSetConfigureManager;
+const auto& putCertificateService = privilegeSetConfigureManager;
+const auto& deleteCertificateService = privilegeSetConfigureManager;
+const auto& postCertificateService = privilegeSetConfigureManager;
+
+// Chassis
+const auto& getChassis = privilegeSetLogin;
+const auto& headChassis = privilegeSetLogin;
+const auto& patchChassis = privilegeSetConfigureComponents;
+const auto& putChassis = privilegeSetConfigureComponents;
+const auto& deleteChassis = privilegeSetConfigureComponents;
+const auto& postChassis = privilegeSetConfigureComponents;
+
+// ChassisCollection
+const auto& getChassisCollection = privilegeSetLogin;
+const auto& headChassisCollection = privilegeSetLogin;
+const auto& patchChassisCollection = privilegeSetConfigureComponents;
+const auto& putChassisCollection = privilegeSetConfigureComponents;
+const auto& deleteChassisCollection = privilegeSetConfigureComponents;
+const auto& postChassisCollection = privilegeSetConfigureComponents;
+
+// Circuit
+const auto& getCircuit = privilegeSetLogin;
+const auto& headCircuit = privilegeSetLogin;
+const auto& patchCircuit = privilegeSetConfigureComponents;
+const auto& putCircuit = privilegeSetConfigureComponents;
+const auto& deleteCircuit = privilegeSetConfigureComponents;
+const auto& postCircuit = privilegeSetConfigureComponents;
+
+// CircuitCollection
+const auto& getCircuitCollection = privilegeSetLogin;
+const auto& headCircuitCollection = privilegeSetLogin;
+const auto& patchCircuitCollection = privilegeSetConfigureComponents;
+const auto& putCircuitCollection = privilegeSetConfigureComponents;
+const auto& deleteCircuitCollection = privilegeSetConfigureComponents;
+const auto& postCircuitCollection = privilegeSetConfigureComponents;
+
+// CompositionService
+const auto& getCompositionService = privilegeSetLogin;
+const auto& headCompositionService = privilegeSetLogin;
+const auto& patchCompositionService = privilegeSetConfigureManager;
+const auto& putCompositionService = privilegeSetConfigureManager;
+const auto& deleteCompositionService = privilegeSetConfigureManager;
+const auto& postCompositionService = privilegeSetConfigureManager;
+
+// ComputerSystem
+const auto& getComputerSystem = privilegeSetLogin;
+const auto& headComputerSystem = privilegeSetLogin;
+const auto& patchComputerSystem = privilegeSetConfigureComponents;
+const auto& postComputerSystem = privilegeSetConfigureComponents;
+const auto& putComputerSystem = privilegeSetConfigureComponents;
+const auto& deleteComputerSystem = privilegeSetConfigureComponents;
+
+// ComputerSystemCollection
+const auto& getComputerSystemCollection = privilegeSetLogin;
+const auto& headComputerSystemCollection = privilegeSetLogin;
+const auto& patchComputerSystemCollection = privilegeSetConfigureComponents;
+const auto& postComputerSystemCollection = privilegeSetConfigureComponents;
+const auto& putComputerSystemCollection = privilegeSetConfigureComponents;
+const auto& deleteComputerSystemCollection = privilegeSetConfigureComponents;
+
+// Connection
+const auto& getConnection = privilegeSetLogin;
+const auto& headConnection = privilegeSetLogin;
+const auto& patchConnection = privilegeSetConfigureComponents;
+const auto& postConnection = privilegeSetConfigureComponents;
+const auto& putConnection = privilegeSetConfigureComponents;
+const auto& deleteConnection = privilegeSetConfigureComponents;
+
+// ConnectionCollection
+const auto& getConnectionCollection = privilegeSetLogin;
+const auto& headConnectionCollection = privilegeSetLogin;
+const auto& patchConnectionCollection = privilegeSetConfigureComponents;
+const auto& postConnectionCollection = privilegeSetConfigureComponents;
+const auto& putConnectionCollection = privilegeSetConfigureComponents;
+const auto& deleteConnectionCollection = privilegeSetConfigureComponents;
+
+// ConnectionMethod
+const auto& getConnectionMethod = privilegeSetLogin;
+const auto& headConnectionMethod = privilegeSetLogin;
+const auto& patchConnectionMethod = privilegeSetConfigureManager;
+const auto& putConnectionMethod = privilegeSetConfigureManager;
+const auto& deleteConnectionMethod = privilegeSetConfigureManager;
+const auto& postConnectionMethod = privilegeSetConfigureManager;
+
+// ConnectionMethodCollection
+const auto& getConnectionMethodCollection = privilegeSetLogin;
+const auto& headConnectionMethodCollection = privilegeSetLogin;
+const auto& patchConnectionMethodCollection = privilegeSetConfigureManager;
+const auto& putConnectionMethodCollection = privilegeSetConfigureManager;
+const auto& deleteConnectionMethodCollection = privilegeSetConfigureManager;
+const auto& postConnectionMethodCollection = privilegeSetConfigureManager;
+
+// Drive
+const auto& getDrive = privilegeSetLogin;
+const auto& headDrive = privilegeSetLogin;
+const auto& patchDrive = privilegeSetConfigureComponents;
+const auto& postDrive = privilegeSetConfigureComponents;
+const auto& putDrive = privilegeSetConfigureComponents;
+const auto& deleteDrive = privilegeSetConfigureComponents;
+
+// DriveCollection
+const auto& getDriveCollection = privilegeSetLogin;
+const auto& headDriveCollection = privilegeSetLogin;
+const auto& patchDriveCollection = privilegeSetConfigureComponents;
+const auto& postDriveCollection = privilegeSetConfigureComponents;
+const auto& putDriveCollection = privilegeSetConfigureComponents;
+const auto& deleteDriveCollection = privilegeSetConfigureComponents;
+
+// Endpoint
+const auto& getEndpoint = privilegeSetLogin;
+const auto& headEndpoint = privilegeSetLogin;
+const auto& patchEndpoint = privilegeSetConfigureComponents;
+const auto& postEndpoint = privilegeSetConfigureComponents;
+const auto& putEndpoint = privilegeSetConfigureComponents;
+const auto& deleteEndpoint = privilegeSetConfigureComponents;
+
+// EndpointCollection
+const auto& getEndpointCollection = privilegeSetLogin;
+const auto& headEndpointCollection = privilegeSetLogin;
+const auto& patchEndpointCollection = privilegeSetConfigureComponents;
+const auto& postEndpointCollection = privilegeSetConfigureComponents;
+const auto& putEndpointCollection = privilegeSetConfigureComponents;
+const auto& deleteEndpointCollection = privilegeSetConfigureComponents;
+
+// EndpointGroup
+const auto& getEndpointGroup = privilegeSetLogin;
+const auto& headEndpointGroup = privilegeSetLogin;
+const auto& patchEndpointGroup = privilegeSetConfigureComponents;
+const auto& postEndpointGroup = privilegeSetConfigureComponents;
+const auto& putEndpointGroup = privilegeSetConfigureComponents;
+const auto& deleteEndpointGroup = privilegeSetConfigureComponents;
+
+// EndpointGroupCollection
+const auto& getEndpointGroupCollection = privilegeSetLogin;
+const auto& headEndpointGroupCollection = privilegeSetLogin;
+const auto& patchEndpointGroupCollection = privilegeSetConfigureComponents;
+const auto& postEndpointGroupCollection = privilegeSetConfigureComponents;
+const auto& putEndpointGroupCollection = privilegeSetConfigureComponents;
+const auto& deleteEndpointGroupCollection = privilegeSetConfigureComponents;
+
+// EthernetInterface
+const auto& getEthernetInterface = privilegeSetLogin;
+const auto& headEthernetInterface = privilegeSetLogin;
+const auto& patchEthernetInterface = privilegeSetConfigureComponents;
+const auto& postEthernetInterface = privilegeSetConfigureComponents;
+const auto& putEthernetInterface = privilegeSetConfigureComponents;
+const auto& deleteEthernetInterface = privilegeSetConfigureComponents;
+
+// EthernetInterfaceCollection
+const auto& getEthernetInterfaceCollection = privilegeSetLogin;
+const auto& headEthernetInterfaceCollection = privilegeSetLogin;
+const auto& patchEthernetInterfaceCollection = privilegeSetConfigureComponents;
+const auto& postEthernetInterfaceCollection = privilegeSetConfigureComponents;
+const auto& putEthernetInterfaceCollection = privilegeSetConfigureComponents;
+const auto& deleteEthernetInterfaceCollection = privilegeSetConfigureComponents;
+
+// EventDestination
+const auto& getEventDestination = privilegeSetLogin;
+const auto& headEventDestination = privilegeSetLogin;
+const auto& patchEventDestination = privilegeSetConfigureManagerOrConfigureSelf;
+const auto& postEventDestination = privilegeSetConfigureManagerOrConfigureSelf;
+const auto& putEventDestination = privilegeSetConfigureManagerOrConfigureSelf;
+const auto& deleteEventDestination =
+    privilegeSetConfigureManagerOrConfigureSelf;
+
+// EventDestinationCollection
+const auto& getEventDestinationCollection = privilegeSetLogin;
+const auto& headEventDestinationCollection = privilegeSetLogin;
+const auto& patchEventDestinationCollection =
+    privilegeSetConfigureManagerOrConfigureComponents;
+const auto& postEventDestinationCollection =
+    privilegeSetConfigureManagerOrConfigureComponents;
+const auto& putEventDestinationCollection =
+    privilegeSetConfigureManagerOrConfigureComponents;
+const auto& deleteEventDestinationCollection =
+    privilegeSetConfigureManagerOrConfigureComponents;
+
+// EventService
+const auto& getEventService = privilegeSetLogin;
+const auto& headEventService = privilegeSetLogin;
+const auto& patchEventService = privilegeSetConfigureManager;
+const auto& postEventService = privilegeSetConfigureManager;
+const auto& putEventService = privilegeSetConfigureManager;
+const auto& deleteEventService = privilegeSetConfigureManager;
+
+// ExternalAccountProvider
+const auto& getExternalAccountProvider = privilegeSetLogin;
+const auto& headExternalAccountProvider = privilegeSetLogin;
+const auto& patchExternalAccountProvider = privilegeSetConfigureManager;
+const auto& putExternalAccountProvider = privilegeSetConfigureManager;
+const auto& deleteExternalAccountProvider = privilegeSetConfigureManager;
+const auto& postExternalAccountProvider = privilegeSetConfigureManager;
+
+// ExternalAccountProviderCollection
+const auto& getExternalAccountProviderCollection = privilegeSetLogin;
+const auto& headExternalAccountProviderCollection = privilegeSetLogin;
+const auto& patchExternalAccountProviderCollection =
+    privilegeSetConfigureManager;
+const auto& putExternalAccountProviderCollection = privilegeSetConfigureManager;
+const auto& deleteExternalAccountProviderCollection =
+    privilegeSetConfigureManager;
+const auto& postExternalAccountProviderCollection =
+    privilegeSetConfigureManager;
+
+// Fabric
+const auto& getFabric = privilegeSetLogin;
+const auto& headFabric = privilegeSetLogin;
+const auto& patchFabric = privilegeSetConfigureComponents;
+const auto& postFabric = privilegeSetConfigureComponents;
+const auto& putFabric = privilegeSetConfigureComponents;
+const auto& deleteFabric = privilegeSetConfigureComponents;
+
+// FabricCollection
+const auto& getFabricCollection = privilegeSetLogin;
+const auto& headFabricCollection = privilegeSetLogin;
+const auto& patchFabricCollection = privilegeSetConfigureComponents;
+const auto& postFabricCollection = privilegeSetConfigureComponents;
+const auto& putFabricCollection = privilegeSetConfigureComponents;
+const auto& deleteFabricCollection = privilegeSetConfigureComponents;
+
+// FabricAdapter
+const auto& getFabricAdapter = privilegeSetLogin;
+const auto& headFabricAdapter = privilegeSetLogin;
+const auto& patchFabricAdapter = privilegeSetConfigureComponents;
+const auto& postFabricAdapter = privilegeSetConfigureComponents;
+const auto& putFabricAdapter = privilegeSetConfigureComponents;
+const auto& deleteFabricAdapter = privilegeSetConfigureComponents;
+
+// FabricAdapterCollection
+const auto& getFabricAdapterCollection = privilegeSetLogin;
+const auto& headFabricAdapterCollection = privilegeSetLogin;
+const auto& patchFabricAdapterCollection = privilegeSetConfigureComponents;
+const auto& postFabricAdapterCollection = privilegeSetConfigureComponents;
+const auto& putFabricAdapterCollection = privilegeSetConfigureComponents;
+const auto& deleteFabricAdapterCollection = privilegeSetConfigureComponents;
+
+// Facility
+const auto& getFacility = privilegeSetLogin;
+const auto& headFacility = privilegeSetLogin;
+const auto& patchFacility = privilegeSetConfigureComponents;
+const auto& putFacility = privilegeSetConfigureComponents;
+const auto& deleteFacility = privilegeSetConfigureComponents;
+const auto& postFacility = privilegeSetConfigureComponents;
+
+// FacilityCollection
+const auto& getFacilityCollection = privilegeSetLogin;
+const auto& headFacilityCollection = privilegeSetLogin;
+const auto& patchFacilityCollection = privilegeSetConfigureComponents;
+const auto& putFacilityCollection = privilegeSetConfigureComponents;
+const auto& deleteFacilityCollection = privilegeSetConfigureComponents;
+const auto& postFacilityCollection = privilegeSetConfigureComponents;
+
+// HostInterface
+const auto& getHostInterface = privilegeSetLogin;
+const auto& headHostInterface = privilegeSetLogin;
+const auto& patchHostInterface = privilegeSetConfigureManager;
+const auto& postHostInterface = privilegeSetConfigureManager;
+const auto& putHostInterface = privilegeSetConfigureManager;
+const auto& deleteHostInterface = privilegeSetConfigureManager;
+
+// HostInterfaceCollection
+const auto& getHostInterfaceCollection = privilegeSetLogin;
+const auto& headHostInterfaceCollection = privilegeSetLogin;
+const auto& patchHostInterfaceCollection = privilegeSetConfigureManager;
+const auto& postHostInterfaceCollection = privilegeSetConfigureManager;
+const auto& putHostInterfaceCollection = privilegeSetConfigureManager;
+const auto& deleteHostInterfaceCollection = privilegeSetConfigureManager;
+
+// Job
+const auto& getJob = privilegeSetLogin;
+const auto& headJob = privilegeSetLogin;
+const auto& patchJob = privilegeSetConfigureManager;
+const auto& putJob = privilegeSetConfigureManager;
+const auto& deleteJob = privilegeSetConfigureManager;
+const auto& postJob = privilegeSetConfigureManager;
+
+// JobCollection
+const auto& getJobCollection = privilegeSetLogin;
+const auto& headJobCollection = privilegeSetLogin;
+const auto& patchJobCollection = privilegeSetConfigureManager;
+const auto& putJobCollection = privilegeSetConfigureManager;
+const auto& deleteJobCollection = privilegeSetConfigureManager;
+const auto& postJobCollection = privilegeSetConfigureManager;
+
+// JobService
+const auto& getJobService = privilegeSetLogin;
+const auto& headJobService = privilegeSetLogin;
+const auto& patchJobService = privilegeSetConfigureManager;
+const auto& putJobService = privilegeSetConfigureManager;
+const auto& deleteJobService = privilegeSetConfigureManager;
+const auto& postJobService = privilegeSetConfigureManager;
+
+// JsonSchemaFile
+const auto& getJsonSchemaFile = privilegeSetLogin;
+const auto& headJsonSchemaFile = privilegeSetLogin;
+const auto& patchJsonSchemaFile = privilegeSetConfigureManager;
+const auto& postJsonSchemaFile = privilegeSetConfigureManager;
+const auto& putJsonSchemaFile = privilegeSetConfigureManager;
+const auto& deleteJsonSchemaFile = privilegeSetConfigureManager;
+
+// JsonSchemaFileCollection
+const auto& getJsonSchemaFileCollection = privilegeSetLogin;
+const auto& headJsonSchemaFileCollection = privilegeSetLogin;
+const auto& patchJsonSchemaFileCollection = privilegeSetConfigureManager;
+const auto& postJsonSchemaFileCollection = privilegeSetConfigureManager;
+const auto& putJsonSchemaFileCollection = privilegeSetConfigureManager;
+const auto& deleteJsonSchemaFileCollection = privilegeSetConfigureManager;
+
+// LogEntry
+const auto& getLogEntry = privilegeSetLogin;
+const auto& headLogEntry = privilegeSetLogin;
+const auto& patchLogEntry = privilegeSetConfigureManager;
+const auto& putLogEntry = privilegeSetConfigureManager;
+const auto& deleteLogEntry = privilegeSetConfigureManager;
+const auto& postLogEntry = privilegeSetConfigureManager;
+
+// LogEntryCollection
+const auto& getLogEntryCollection = privilegeSetLogin;
+const auto& headLogEntryCollection = privilegeSetLogin;
+const auto& patchLogEntryCollection = privilegeSetConfigureManager;
+const auto& putLogEntryCollection = privilegeSetConfigureManager;
+const auto& deleteLogEntryCollection = privilegeSetConfigureManager;
+const auto& postLogEntryCollection = privilegeSetConfigureManager;
+
+// LogService
+const auto& getLogService = privilegeSetLogin;
+const auto& headLogService = privilegeSetLogin;
+const auto& patchLogService = privilegeSetConfigureManager;
+const auto& putLogService = privilegeSetConfigureManager;
+const auto& deleteLogService = privilegeSetConfigureManager;
+const auto& postLogService = privilegeSetConfigureManager;
+
+// LogServiceCollection
+const auto& getLogServiceCollection = privilegeSetLogin;
+const auto& headLogServiceCollection = privilegeSetLogin;
+const auto& patchLogServiceCollection = privilegeSetConfigureManager;
+const auto& putLogServiceCollection = privilegeSetConfigureManager;
+const auto& deleteLogServiceCollection = privilegeSetConfigureManager;
+const auto& postLogServiceCollection = privilegeSetConfigureManager;
+
+// Manager
+const auto& getManager = privilegeSetLogin;
+const auto& headManager = privilegeSetLogin;
+const auto& patchManager = privilegeSetConfigureManager;
+const auto& postManager = privilegeSetConfigureManager;
+const auto& putManager = privilegeSetConfigureManager;
+const auto& deleteManager = privilegeSetConfigureManager;
+
+// ManagerCollection
+const auto& getManagerCollection = privilegeSetLogin;
+const auto& headManagerCollection = privilegeSetLogin;
+const auto& patchManagerCollection = privilegeSetConfigureManager;
+const auto& postManagerCollection = privilegeSetConfigureManager;
+const auto& putManagerCollection = privilegeSetConfigureManager;
+const auto& deleteManagerCollection = privilegeSetConfigureManager;
+
+// ManagerAccount
+const auto& getManagerAccount =
+    privilegeSetConfigureManagerOrConfigureUsersOrConfigureSelf;
+const auto& headManagerAccount = privilegeSetLogin;
+const auto& patchManagerAccount = privilegeSetConfigureUsers;
+const auto& postManagerAccount = privilegeSetConfigureUsers;
+const auto& putManagerAccount = privilegeSetConfigureUsers;
+const auto& deleteManagerAccount = privilegeSetConfigureUsers;
+
+// ManagerAccountCollection
+const auto& getManagerAccountCollection = privilegeSetLogin;
+const auto& headManagerAccountCollection = privilegeSetLogin;
+const auto& patchManagerAccountCollection = privilegeSetConfigureUsers;
+const auto& putManagerAccountCollection = privilegeSetConfigureUsers;
+const auto& deleteManagerAccountCollection = privilegeSetConfigureUsers;
+const auto& postManagerAccountCollection = privilegeSetConfigureUsers;
+
+// ManagerNetworkProtocol
+const auto& getManagerNetworkProtocol = privilegeSetLogin;
+const auto& headManagerNetworkProtocol = privilegeSetLogin;
+const auto& patchManagerNetworkProtocol = privilegeSetConfigureManager;
+const auto& postManagerNetworkProtocol = privilegeSetConfigureManager;
+const auto& putManagerNetworkProtocol = privilegeSetConfigureManager;
+const auto& deleteManagerNetworkProtocol = privilegeSetConfigureManager;
+
+// MediaController
+const auto& getMediaController = privilegeSetLogin;
+const auto& headMediaController = privilegeSetLogin;
+const auto& patchMediaController = privilegeSetConfigureComponents;
+const auto& postMediaController = privilegeSetConfigureComponents;
+const auto& putMediaController = privilegeSetConfigureComponents;
+const auto& deleteMediaController = privilegeSetConfigureComponents;
+
+// MediaControllerCollection
+const auto& getMediaControllerCollection = privilegeSetLogin;
+const auto& headMediaControllerCollection = privilegeSetLogin;
+const auto& patchMediaControllerCollection = privilegeSetConfigureComponents;
+const auto& postMediaControllerCollection = privilegeSetConfigureComponents;
+const auto& putMediaControllerCollection = privilegeSetConfigureComponents;
+const auto& deleteMediaControllerCollection = privilegeSetConfigureComponents;
+
+// Memory
+const auto& getMemory = privilegeSetLogin;
+const auto& headMemory = privilegeSetLogin;
+const auto& patchMemory = privilegeSetConfigureComponents;
+const auto& postMemory = privilegeSetConfigureComponents;
+const auto& putMemory = privilegeSetConfigureComponents;
+const auto& deleteMemory = privilegeSetConfigureComponents;
+
+// MemoryCollection
+const auto& getMemoryCollection = privilegeSetLogin;
+const auto& headMemoryCollection = privilegeSetLogin;
+const auto& patchMemoryCollection = privilegeSetConfigureComponents;
+const auto& postMemoryCollection = privilegeSetConfigureComponents;
+const auto& putMemoryCollection = privilegeSetConfigureComponents;
+const auto& deleteMemoryCollection = privilegeSetConfigureComponents;
+
+// MemoryChunks
+const auto& getMemoryChunks = privilegeSetLogin;
+const auto& headMemoryChunks = privilegeSetLogin;
+const auto& patchMemoryChunks = privilegeSetConfigureComponents;
+const auto& postMemoryChunks = privilegeSetConfigureComponents;
+const auto& putMemoryChunks = privilegeSetConfigureComponents;
+const auto& deleteMemoryChunks = privilegeSetConfigureComponents;
+
+// MemoryChunksCollection
+const auto& getMemoryChunksCollection = privilegeSetLogin;
+const auto& headMemoryChunksCollection = privilegeSetLogin;
+const auto& patchMemoryChunksCollection = privilegeSetConfigureComponents;
+const auto& postMemoryChunksCollection = privilegeSetConfigureComponents;
+const auto& putMemoryChunksCollection = privilegeSetConfigureComponents;
+const auto& deleteMemoryChunksCollection = privilegeSetConfigureComponents;
+
+// MemoryDomain
+const auto& getMemoryDomain = privilegeSetLogin;
+const auto& headMemoryDomain = privilegeSetLogin;
+const auto& patchMemoryDomain = privilegeSetConfigureComponents;
+const auto& postMemoryDomain = privilegeSetConfigureComponents;
+const auto& putMemoryDomain = privilegeSetConfigureComponents;
+const auto& deleteMemoryDomain = privilegeSetConfigureComponents;
+
+// MemoryDomainCollection
+const auto& getMemoryDomainCollection = privilegeSetLogin;
+const auto& headMemoryDomainCollection = privilegeSetLogin;
+const auto& patchMemoryDomainCollection = privilegeSetConfigureComponents;
+const auto& postMemoryDomainCollection = privilegeSetConfigureComponents;
+const auto& putMemoryDomainCollection = privilegeSetConfigureComponents;
+const auto& deleteMemoryDomainCollection = privilegeSetConfigureComponents;
+
+// MemoryMetrics
+const auto& getMemoryMetrics = privilegeSetLogin;
+const auto& headMemoryMetrics = privilegeSetLogin;
+const auto& patchMemoryMetrics = privilegeSetConfigureComponents;
+const auto& postMemoryMetrics = privilegeSetConfigureComponents;
+const auto& putMemoryMetrics = privilegeSetConfigureComponents;
+const auto& deleteMemoryMetrics = privilegeSetConfigureComponents;
+
+// MessageRegistryFile
+const auto& getMessageRegistryFile = privilegeSetLogin;
+const auto& headMessageRegistryFile = privilegeSetLogin;
+const auto& patchMessageRegistryFile = privilegeSetConfigureManager;
+const auto& postMessageRegistryFile = privilegeSetConfigureManager;
+const auto& putMessageRegistryFile = privilegeSetConfigureManager;
+const auto& deleteMessageRegistryFile = privilegeSetConfigureManager;
+
+// MessageRegistryFileCollection
+const auto& getMessageRegistryFileCollection = privilegeSetLogin;
+const auto& headMessageRegistryFileCollection = privilegeSetLogin;
+const auto& patchMessageRegistryFileCollection = privilegeSetConfigureManager;
+const auto& postMessageRegistryFileCollection = privilegeSetConfigureManager;
+const auto& putMessageRegistryFileCollection = privilegeSetConfigureManager;
+const auto& deleteMessageRegistryFileCollection = privilegeSetConfigureManager;
+
+// MetricDefinition
+const auto& getMetricDefinition = privilegeSetLogin;
+const auto& headMetricDefinition = privilegeSetLogin;
+const auto& patchMetricDefinition = privilegeSetConfigureManager;
+const auto& putMetricDefinition = privilegeSetConfigureManager;
+const auto& deleteMetricDefinition = privilegeSetConfigureManager;
+const auto& postMetricDefinition = privilegeSetConfigureManager;
+
+// MetricDefinitionCollection
+const auto& getMetricDefinitionCollection = privilegeSetLogin;
+const auto& headMetricDefinitionCollection = privilegeSetLogin;
+const auto& patchMetricDefinitionCollection = privilegeSetConfigureManager;
+const auto& putMetricDefinitionCollection = privilegeSetConfigureManager;
+const auto& deleteMetricDefinitionCollection = privilegeSetConfigureManager;
+const auto& postMetricDefinitionCollection = privilegeSetConfigureManager;
+
+// MetricReport
+const auto& getMetricReport = privilegeSetLogin;
+const auto& headMetricReport = privilegeSetLogin;
+const auto& patchMetricReport = privilegeSetConfigureManager;
+const auto& putMetricReport = privilegeSetConfigureManager;
+const auto& deleteMetricReport = privilegeSetConfigureManager;
+const auto& postMetricReport = privilegeSetConfigureManager;
+
+// MetricReportCollection
+const auto& getMetricReportCollection = privilegeSetLogin;
+const auto& headMetricReportCollection = privilegeSetLogin;
+const auto& patchMetricReportCollection = privilegeSetConfigureManager;
+const auto& putMetricReportCollection = privilegeSetConfigureManager;
+const auto& deleteMetricReportCollection = privilegeSetConfigureManager;
+const auto& postMetricReportCollection = privilegeSetConfigureManager;
+
+// MetricReportDefinition
+const auto& getMetricReportDefinition = privilegeSetLogin;
+const auto& headMetricReportDefinition = privilegeSetLogin;
+const auto& patchMetricReportDefinition = privilegeSetConfigureManager;
+const auto& putMetricReportDefinition = privilegeSetConfigureManager;
+const auto& deleteMetricReportDefinition = privilegeSetConfigureManager;
+const auto& postMetricReportDefinition = privilegeSetConfigureManager;
+
+// MetricReportDefinitionCollection
+const auto& getMetricReportDefinitionCollection = privilegeSetLogin;
+const auto& headMetricReportDefinitionCollection = privilegeSetLogin;
+const auto& patchMetricReportDefinitionCollection =
+    privilegeSetConfigureManager;
+const auto& putMetricReportDefinitionCollection = privilegeSetConfigureManager;
+const auto& deleteMetricReportDefinitionCollection =
+    privilegeSetConfigureManager;
+const auto& postMetricReportDefinitionCollection = privilegeSetConfigureManager;
+
+// NetworkAdapter
+const auto& getNetworkAdapter = privilegeSetLogin;
+const auto& headNetworkAdapter = privilegeSetLogin;
+const auto& patchNetworkAdapter = privilegeSetConfigureComponents;
+const auto& postNetworkAdapter = privilegeSetConfigureComponents;
+const auto& putNetworkAdapter = privilegeSetConfigureComponents;
+const auto& deleteNetworkAdapter = privilegeSetConfigureComponents;
+
+// NetworkAdapterCollection
+const auto& getNetworkAdapterCollection = privilegeSetLogin;
+const auto& headNetworkAdapterCollection = privilegeSetLogin;
+const auto& patchNetworkAdapterCollection = privilegeSetConfigureComponents;
+const auto& postNetworkAdapterCollection = privilegeSetConfigureComponents;
+const auto& putNetworkAdapterCollection = privilegeSetConfigureComponents;
+const auto& deleteNetworkAdapterCollection = privilegeSetConfigureComponents;
+
+// NetworkDeviceFunction
+const auto& getNetworkDeviceFunction = privilegeSetLogin;
+const auto& headNetworkDeviceFunction = privilegeSetLogin;
+const auto& patchNetworkDeviceFunction = privilegeSetConfigureComponents;
+const auto& postNetworkDeviceFunction = privilegeSetConfigureComponents;
+const auto& putNetworkDeviceFunction = privilegeSetConfigureComponents;
+const auto& deleteNetworkDeviceFunction = privilegeSetConfigureComponents;
+
+// NetworkDeviceFunctionCollection
+const auto& getNetworkDeviceFunctionCollection = privilegeSetLogin;
+const auto& headNetworkDeviceFunctionCollection = privilegeSetLogin;
+const auto& patchNetworkDeviceFunctionCollection =
+    privilegeSetConfigureComponents;
+const auto& postNetworkDeviceFunctionCollection =
+    privilegeSetConfigureComponents;
+const auto& putNetworkDeviceFunctionCollection =
+    privilegeSetConfigureComponents;
+const auto& deleteNetworkDeviceFunctionCollection =
+    privilegeSetConfigureComponents;
+
+// NetworkInterface
+const auto& getNetworkInterface = privilegeSetLogin;
+const auto& headNetworkInterface = privilegeSetLogin;
+const auto& patchNetworkInterface = privilegeSetConfigureComponents;
+const auto& postNetworkInterface = privilegeSetConfigureComponents;
+const auto& putNetworkInterface = privilegeSetConfigureComponents;
+const auto& deleteNetworkInterface = privilegeSetConfigureComponents;
+
+// NetworkInterfaceCollection
+const auto& getNetworkInterfaceCollection = privilegeSetLogin;
+const auto& headNetworkInterfaceCollection = privilegeSetLogin;
+const auto& patchNetworkInterfaceCollection = privilegeSetConfigureComponents;
+const auto& postNetworkInterfaceCollection = privilegeSetConfigureComponents;
+const auto& putNetworkInterfaceCollection = privilegeSetConfigureComponents;
+const auto& deleteNetworkInterfaceCollection = privilegeSetConfigureComponents;
+
+// NetworkPort
+const auto& getNetworkPort = privilegeSetLogin;
+const auto& headNetworkPort = privilegeSetLogin;
+const auto& patchNetworkPort = privilegeSetConfigureComponents;
+const auto& postNetworkPort = privilegeSetConfigureComponents;
+const auto& putNetworkPort = privilegeSetConfigureComponents;
+const auto& deleteNetworkPort = privilegeSetConfigureComponents;
+
+// NetworkPortCollection
+const auto& getNetworkPortCollection = privilegeSetLogin;
+const auto& headNetworkPortCollection = privilegeSetLogin;
+const auto& patchNetworkPortCollection = privilegeSetConfigureComponents;
+const auto& postNetworkPortCollection = privilegeSetConfigureComponents;
+const auto& putNetworkPortCollection = privilegeSetConfigureComponents;
+const auto& deleteNetworkPortCollection = privilegeSetConfigureComponents;
+
+// OperatingConfig
+const auto& getOperatingConfig = privilegeSetLogin;
+const auto& headOperatingConfig = privilegeSetLogin;
+const auto& patchOperatingConfig = privilegeSetConfigureComponents;
+const auto& postOperatingConfig = privilegeSetConfigureComponents;
+const auto& putOperatingConfig = privilegeSetConfigureComponents;
+const auto& deleteOperatingConfig = privilegeSetConfigureComponents;
+
+// OperatingConfigCollection
+const auto& getOperatingConfigCollection = privilegeSetLogin;
+const auto& headOperatingConfigCollection = privilegeSetLogin;
+const auto& patchOperatingConfigCollection = privilegeSetConfigureComponents;
+const auto& postOperatingConfigCollection = privilegeSetConfigureComponents;
+const auto& putOperatingConfigCollection = privilegeSetConfigureComponents;
+const auto& deleteOperatingConfigCollection = privilegeSetConfigureComponents;
+
+// Outlet
+const auto& getOutlet = privilegeSetLogin;
+const auto& headOutlet = privilegeSetLogin;
+const auto& patchOutlet = privilegeSetConfigureComponents;
+const auto& postOutlet = privilegeSetConfigureComponents;
+const auto& putOutlet = privilegeSetConfigureComponents;
+const auto& deleteOutlet = privilegeSetConfigureComponents;
+
+// OutletCollection
+const auto& getOutletCollection = privilegeSetLogin;
+const auto& headOutletCollection = privilegeSetLogin;
+const auto& patchOutletCollection = privilegeSetConfigureComponents;
+const auto& postOutletCollection = privilegeSetConfigureComponents;
+const auto& putOutletCollection = privilegeSetConfigureComponents;
+const auto& deleteOutletCollection = privilegeSetConfigureComponents;
+
+// OutletGroup
+const auto& getOutletGroup = privilegeSetLogin;
+const auto& headOutletGroup = privilegeSetLogin;
+const auto& patchOutletGroup = privilegeSetConfigureComponents;
+const auto& postOutletGroup = privilegeSetConfigureComponents;
+const auto& putOutletGroup = privilegeSetConfigureComponents;
+const auto& deleteOutletGroup = privilegeSetConfigureComponents;
+
+// OutletGroupCollection
+const auto& getOutletGroupCollection = privilegeSetLogin;
+const auto& headOutletGroupCollection = privilegeSetLogin;
+const auto& patchOutletGroupCollection = privilegeSetConfigureComponents;
+const auto& postOutletGroupCollection = privilegeSetConfigureComponents;
+const auto& putOutletGroupCollection = privilegeSetConfigureComponents;
+const auto& deleteOutletGroupCollection = privilegeSetConfigureComponents;
+
+// PCIeDevice
+const auto& getPCIeDevice = privilegeSetLogin;
+const auto& headPCIeDevice = privilegeSetLogin;
+const auto& patchPCIeDevice = privilegeSetConfigureComponents;
+const auto& postPCIeDevice = privilegeSetConfigureComponents;
+const auto& putPCIeDevice = privilegeSetConfigureComponents;
+const auto& deletePCIeDevice = privilegeSetConfigureComponents;
+
+// PCIeDeviceCollection
+const auto& getPCIeDeviceCollection = privilegeSetLogin;
+const auto& headPCIeDeviceCollection = privilegeSetLogin;
+const auto& patchPCIeDeviceCollection = privilegeSetConfigureComponents;
+const auto& postPCIeDeviceCollection = privilegeSetConfigureComponents;
+const auto& putPCIeDeviceCollection = privilegeSetConfigureComponents;
+const auto& deletePCIeDeviceCollection = privilegeSetConfigureComponents;
+
+// PCIeFunction
+const auto& getPCIeFunction = privilegeSetLogin;
+const auto& headPCIeFunction = privilegeSetLogin;
+const auto& patchPCIeFunction = privilegeSetConfigureComponents;
+const auto& postPCIeFunction = privilegeSetConfigureComponents;
+const auto& putPCIeFunction = privilegeSetConfigureComponents;
+const auto& deletePCIeFunction = privilegeSetConfigureComponents;
+
+// PCIeFunctionCollection
+const auto& getPCIeFunctionCollection = privilegeSetLogin;
+const auto& headPCIeFunctionCollection = privilegeSetLogin;
+const auto& patchPCIeFunctionCollection = privilegeSetConfigureComponents;
+const auto& postPCIeFunctionCollection = privilegeSetConfigureComponents;
+const auto& putPCIeFunctionCollection = privilegeSetConfigureComponents;
+const auto& deletePCIeFunctionCollection = privilegeSetConfigureComponents;
+
+// PCIeSlots
+const auto& getPCIeSlots = privilegeSetLogin;
+const auto& headPCIeSlots = privilegeSetLogin;
+const auto& patchPCIeSlots = privilegeSetConfigureComponents;
+const auto& postPCIeSlots = privilegeSetConfigureComponents;
+const auto& putPCIeSlots = privilegeSetConfigureComponents;
+const auto& deletePCIeSlots = privilegeSetConfigureComponents;
+
+// Port
+const auto& getPort = privilegeSetLogin;
+const auto& headPort = privilegeSetLogin;
+const auto& patchPort = privilegeSetConfigureComponents;
+const auto& postPort = privilegeSetConfigureComponents;
+const auto& putPort = privilegeSetConfigureComponents;
+const auto& deletePort = privilegeSetConfigureComponents;
+
+// PortCollection
+const auto& getPortCollection = privilegeSetLogin;
+const auto& headPortCollection = privilegeSetLogin;
+const auto& patchPortCollection = privilegeSetConfigureComponents;
+const auto& postPortCollection = privilegeSetConfigureComponents;
+const auto& putPortCollection = privilegeSetConfigureComponents;
+const auto& deletePortCollection = privilegeSetConfigureComponents;
+
+// PortMetrics
+const auto& getPortMetrics = privilegeSetLogin;
+const auto& headPortMetrics = privilegeSetLogin;
+const auto& patchPortMetrics = privilegeSetConfigureComponents;
+const auto& postPortMetrics = privilegeSetConfigureComponents;
+const auto& putPortMetrics = privilegeSetConfigureComponents;
+const auto& deletePortMetrics = privilegeSetConfigureComponents;
+
+// Power
+const auto& getPower = privilegeSetLogin;
+const auto& headPower = privilegeSetLogin;
+const auto& patchPower = privilegeSetConfigureManager;
+const auto& putPower = privilegeSetConfigureManager;
+const auto& deletePower = privilegeSetConfigureManager;
+const auto& postPower = privilegeSetConfigureManager;
+
+// PowerDistribution
+const auto& getPowerDistribution = privilegeSetLogin;
+const auto& headPowerDistribution = privilegeSetLogin;
+const auto& patchPowerDistribution = privilegeSetConfigureComponents;
+const auto& postPowerDistribution = privilegeSetConfigureComponents;
+const auto& putPowerDistribution = privilegeSetConfigureComponents;
+const auto& deletePowerDistribution = privilegeSetConfigureComponents;
+
+// PowerDistributionCollection
+const auto& getPowerDistributionCollection = privilegeSetLogin;
+const auto& headPowerDistributionCollection = privilegeSetLogin;
+const auto& patchPowerDistributionCollection = privilegeSetConfigureComponents;
+const auto& postPowerDistributionCollection = privilegeSetConfigureComponents;
+const auto& putPowerDistributionCollection = privilegeSetConfigureComponents;
+const auto& deletePowerDistributionCollection = privilegeSetConfigureComponents;
+
+// PowerDistributionMetrics
+const auto& getPowerDistributionMetrics = privilegeSetLogin;
+const auto& headPowerDistributionMetrics = privilegeSetLogin;
+const auto& patchPowerDistributionMetrics = privilegeSetConfigureComponents;
+const auto& postPowerDistributionMetrics = privilegeSetConfigureComponents;
+const auto& putPowerDistributionMetrics = privilegeSetConfigureComponents;
+const auto& deletePowerDistributionMetrics = privilegeSetConfigureComponents;
+
+// Processor
+const auto& getProcessor = privilegeSetLogin;
+const auto& headProcessor = privilegeSetLogin;
+const auto& patchProcessor = privilegeSetConfigureComponents;
+const auto& putProcessor = privilegeSetConfigureComponents;
+const auto& deleteProcessor = privilegeSetConfigureComponents;
+const auto& postProcessor = privilegeSetConfigureComponents;
+
+// ProcessorCollection
+const auto& getProcessorCollection = privilegeSetLogin;
+const auto& headProcessorCollection = privilegeSetLogin;
+const auto& patchProcessorCollection = privilegeSetConfigureComponents;
+const auto& putProcessorCollection = privilegeSetConfigureComponents;
+const auto& deleteProcessorCollection = privilegeSetConfigureComponents;
+const auto& postProcessorCollection = privilegeSetConfigureComponents;
+
+// ProcessorMetrics
+const auto& getProcessorMetrics = privilegeSetLogin;
+const auto& headProcessorMetrics = privilegeSetLogin;
+const auto& patchProcessorMetrics = privilegeSetConfigureComponents;
+const auto& putProcessorMetrics = privilegeSetConfigureComponents;
+const auto& deleteProcessorMetrics = privilegeSetConfigureComponents;
+const auto& postProcessorMetrics = privilegeSetConfigureComponents;
+
+// ResourceBlock
+const auto& getResourceBlock = privilegeSetLogin;
+const auto& headResourceBlock = privilegeSetLogin;
+const auto& patchResourceBlock = privilegeSetConfigureComponents;
+const auto& putResourceBlock = privilegeSetConfigureComponents;
+const auto& deleteResourceBlock = privilegeSetConfigureComponents;
+const auto& postResourceBlock = privilegeSetConfigureComponents;
+
+// ResourceBlockCollection
+const auto& getResourceBlockCollection = privilegeSetLogin;
+const auto& headResourceBlockCollection = privilegeSetLogin;
+const auto& patchResourceBlockCollection = privilegeSetConfigureComponents;
+const auto& putResourceBlockCollection = privilegeSetConfigureComponents;
+const auto& deleteResourceBlockCollection = privilegeSetConfigureComponents;
+const auto& postResourceBlockCollection = privilegeSetConfigureComponents;
+
+// Role
+const auto& getRole = privilegeSetLogin;
+const auto& headRole = privilegeSetLogin;
+const auto& patchRole = privilegeSetConfigureManager;
+const auto& putRole = privilegeSetConfigureManager;
+const auto& deleteRole = privilegeSetConfigureManager;
+const auto& postRole = privilegeSetConfigureManager;
+
+// RoleCollection
+const auto& getRoleCollection = privilegeSetLogin;
+const auto& headRoleCollection = privilegeSetLogin;
+const auto& patchRoleCollection = privilegeSetConfigureManager;
+const auto& putRoleCollection = privilegeSetConfigureManager;
+const auto& deleteRoleCollection = privilegeSetConfigureManager;
+const auto& postRoleCollection = privilegeSetConfigureManager;
+
+// RouteEntry
+const auto& getRouteEntry = privilegeSetLogin;
+const auto& headRouteEntry = privilegeSetLogin;
+const auto& patchRouteEntry = privilegeSetConfigureComponents;
+const auto& putRouteEntry = privilegeSetConfigureComponents;
+const auto& deleteRouteEntry = privilegeSetConfigureComponents;
+const auto& postRouteEntry = privilegeSetConfigureComponents;
+
+// RouteEntryCollection
+const auto& getRouteEntryCollection = privilegeSetLogin;
+const auto& headRouteEntryCollection = privilegeSetLogin;
+const auto& patchRouteEntryCollection = privilegeSetConfigureComponents;
+const auto& putRouteEntryCollection = privilegeSetConfigureComponents;
+const auto& deleteRouteEntryCollection = privilegeSetConfigureComponents;
+const auto& postRouteEntryCollection = privilegeSetConfigureComponents;
+
+// RouteEntrySet
+const auto& getRouteEntrySet = privilegeSetLogin;
+const auto& headRouteEntrySet = privilegeSetLogin;
+const auto& patchRouteEntrySet = privilegeSetConfigureComponents;
+const auto& putRouteEntrySet = privilegeSetConfigureComponents;
+const auto& deleteRouteEntrySet = privilegeSetConfigureComponents;
+const auto& postRouteEntrySet = privilegeSetConfigureComponents;
+
+// RouteEntrySetCollection
+const auto& getRouteEntrySetCollection = privilegeSetLogin;
+const auto& headRouteEntrySetCollection = privilegeSetLogin;
+const auto& patchRouteEntrySetCollection = privilegeSetConfigureComponents;
+const auto& putRouteEntrySetCollection = privilegeSetConfigureComponents;
+const auto& deleteRouteEntrySetCollection = privilegeSetConfigureComponents;
+const auto& postRouteEntrySetCollection = privilegeSetConfigureComponents;
+
+// SecureBoot
+const auto& getSecureBoot = privilegeSetLogin;
+const auto& headSecureBoot = privilegeSetLogin;
+const auto& patchSecureBoot = privilegeSetConfigureComponents;
+const auto& postSecureBoot = privilegeSetConfigureComponents;
+const auto& putSecureBoot = privilegeSetConfigureComponents;
+const auto& deleteSecureBoot = privilegeSetConfigureComponents;
+
+// SecureBootDatabase
+const auto& getSecureBootDatabase = privilegeSetLogin;
+const auto& headSecureBootDatabase = privilegeSetLogin;
+const auto& patchSecureBootDatabase = privilegeSetConfigureComponents;
+const auto& postSecureBootDatabase = privilegeSetConfigureComponents;
+const auto& putSecureBootDatabase = privilegeSetConfigureComponents;
+const auto& deleteSecureBootDatabase = privilegeSetConfigureComponents;
+
+// SecureBootDatabaseCollection
+const auto& getSecureBootDatabaseCollection = privilegeSetLogin;
+const auto& headSecureBootDatabaseCollection = privilegeSetLogin;
+const auto& patchSecureBootDatabaseCollection = privilegeSetConfigureComponents;
+const auto& postSecureBootDatabaseCollection = privilegeSetConfigureComponents;
+const auto& putSecureBootDatabaseCollection = privilegeSetConfigureComponents;
+const auto& deleteSecureBootDatabaseCollection =
+    privilegeSetConfigureComponents;
+
+// Sensor
+const auto& getSensor = privilegeSetLogin;
+const auto& headSensor = privilegeSetLogin;
+const auto& patchSensor = privilegeSetConfigureComponents;
+const auto& postSensor = privilegeSetConfigureComponents;
+const auto& putSensor = privilegeSetConfigureComponents;
+const auto& deleteSensor = privilegeSetConfigureComponents;
+
+// SensorCollection
+const auto& getSensorCollection = privilegeSetLogin;
+const auto& headSensorCollection = privilegeSetLogin;
+const auto& patchSensorCollection = privilegeSetConfigureComponents;
+const auto& postSensorCollection = privilegeSetConfigureComponents;
+const auto& putSensorCollection = privilegeSetConfigureComponents;
+const auto& deleteSensorCollection = privilegeSetConfigureComponents;
+
+// SerialInterface
+const auto& getSerialInterface = privilegeSetLogin;
+const auto& headSerialInterface = privilegeSetLogin;
+const auto& patchSerialInterface = privilegeSetConfigureManager;
+const auto& putSerialInterface = privilegeSetConfigureManager;
+const auto& deleteSerialInterface = privilegeSetConfigureManager;
+const auto& postSerialInterface = privilegeSetConfigureManager;
+
+// SerialInterfaceCollection
+const auto& getSerialInterfaceCollection = privilegeSetLogin;
+const auto& headSerialInterfaceCollection = privilegeSetLogin;
+const auto& patchSerialInterfaceCollection = privilegeSetConfigureManager;
+const auto& putSerialInterfaceCollection = privilegeSetConfigureManager;
+const auto& deleteSerialInterfaceCollection = privilegeSetConfigureManager;
+const auto& postSerialInterfaceCollection = privilegeSetConfigureManager;
+
+// ServiceRoot
+const auto& getServiceRoot = privilegeSetLoginOrNoAuth;
+const auto& headServiceRoot = privilegeSetLoginOrNoAuth;
+const auto& patchServiceRoot = privilegeSetConfigureManager;
+const auto& putServiceRoot = privilegeSetConfigureManager;
+const auto& deleteServiceRoot = privilegeSetConfigureManager;
+const auto& postServiceRoot = privilegeSetConfigureManager;
+
+// Session
+const auto& getSession = privilegeSetLogin;
+const auto& headSession = privilegeSetLogin;
+const auto& patchSession = privilegeSetConfigureManager;
+const auto& putSession = privilegeSetConfigureManager;
+const auto& deleteSession = privilegeSetConfigureManagerOrConfigureSelf;
+const auto& postSession = privilegeSetConfigureManager;
+
+// SessionCollection
+const auto& getSessionCollection = privilegeSetLogin;
+const auto& headSessionCollection = privilegeSetLogin;
+const auto& patchSessionCollection = privilegeSetConfigureManager;
+const auto& putSessionCollection = privilegeSetConfigureManager;
+const auto& deleteSessionCollection = privilegeSetConfigureManager;
+const auto& postSessionCollection = privilegeSetLogin;
+
+// SessionService
+const auto& getSessionService = privilegeSetLogin;
+const auto& headSessionService = privilegeSetLogin;
+const auto& patchSessionService = privilegeSetConfigureManager;
+const auto& putSessionService = privilegeSetConfigureManager;
+const auto& deleteSessionService = privilegeSetConfigureManager;
+const auto& postSessionService = privilegeSetConfigureManager;
+
+// Signature
+const auto& getSignature = privilegeSetLogin;
+const auto& headSignature = privilegeSetLogin;
+const auto& patchSignature = privilegeSetConfigureComponents;
+const auto& postSignature = privilegeSetConfigureComponents;
+const auto& putSignature = privilegeSetConfigureComponents;
+const auto& deleteSignature = privilegeSetConfigureComponents;
+
+// SignatureCollection
+const auto& getSignatureCollection = privilegeSetLogin;
+const auto& headSignatureCollection = privilegeSetLogin;
+const auto& patchSignatureCollection = privilegeSetConfigureComponents;
+const auto& postSignatureCollection = privilegeSetConfigureComponents;
+const auto& putSignatureCollection = privilegeSetConfigureComponents;
+const auto& deleteSignatureCollection = privilegeSetConfigureComponents;
+
+// SimpleStorage
+const auto& getSimpleStorage = privilegeSetLogin;
+const auto& headSimpleStorage = privilegeSetLogin;
+const auto& patchSimpleStorage = privilegeSetConfigureComponents;
+const auto& postSimpleStorage = privilegeSetConfigureComponents;
+const auto& putSimpleStorage = privilegeSetConfigureComponents;
+const auto& deleteSimpleStorage = privilegeSetConfigureComponents;
+
+// SimpleStorageCollection
+const auto& getSimpleStorageCollection = privilegeSetLogin;
+const auto& headSimpleStorageCollection = privilegeSetLogin;
+const auto& patchSimpleStorageCollection = privilegeSetConfigureComponents;
+const auto& postSimpleStorageCollection = privilegeSetConfigureComponents;
+const auto& putSimpleStorageCollection = privilegeSetConfigureComponents;
+const auto& deleteSimpleStorageCollection = privilegeSetConfigureComponents;
+
+// SoftwareInventory
+const auto& getSoftwareInventory = privilegeSetLogin;
+const auto& headSoftwareInventory = privilegeSetLogin;
+const auto& patchSoftwareInventory = privilegeSetConfigureComponents;
+const auto& postSoftwareInventory = privilegeSetConfigureComponents;
+const auto& putSoftwareInventory = privilegeSetConfigureComponents;
+const auto& deleteSoftwareInventory = privilegeSetConfigureComponents;
+
+// SoftwareInventoryCollection
+const auto& getSoftwareInventoryCollection = privilegeSetLogin;
+const auto& headSoftwareInventoryCollection = privilegeSetLogin;
+const auto& patchSoftwareInventoryCollection = privilegeSetConfigureComponents;
+const auto& postSoftwareInventoryCollection = privilegeSetConfigureComponents;
+const auto& putSoftwareInventoryCollection = privilegeSetConfigureComponents;
+const auto& deleteSoftwareInventoryCollection = privilegeSetConfigureComponents;
+
+// Storage
+const auto& getStorage = privilegeSetLogin;
+const auto& headStorage = privilegeSetLogin;
+const auto& patchStorage = privilegeSetConfigureComponents;
+const auto& postStorage = privilegeSetConfigureComponents;
+const auto& putStorage = privilegeSetConfigureComponents;
+const auto& deleteStorage = privilegeSetConfigureComponents;
+
+// StorageCollection
+const auto& getStorageCollection = privilegeSetLogin;
+const auto& headStorageCollection = privilegeSetLogin;
+const auto& patchStorageCollection = privilegeSetConfigureComponents;
+const auto& postStorageCollection = privilegeSetConfigureComponents;
+const auto& putStorageCollection = privilegeSetConfigureComponents;
+const auto& deleteStorageCollection = privilegeSetConfigureComponents;
+
+// StorageController
+const auto& getStorageController = privilegeSetLogin;
+const auto& headStorageController = privilegeSetLogin;
+const auto& patchStorageController = privilegeSetConfigureComponents;
+const auto& postStorageController = privilegeSetConfigureComponents;
+const auto& putStorageController = privilegeSetConfigureComponents;
+const auto& deleteStorageController = privilegeSetConfigureComponents;
+
+// StorageControllerCollection
+const auto& getStorageControllerCollection = privilegeSetLogin;
+const auto& headStorageControllerCollection = privilegeSetLogin;
+const auto& patchStorageControllerCollection = privilegeSetConfigureComponents;
+const auto& postStorageControllerCollection = privilegeSetConfigureComponents;
+const auto& putStorageControllerCollection = privilegeSetConfigureComponents;
+const auto& deleteStorageControllerCollection = privilegeSetConfigureComponents;
+
+// Switch
+const auto& getSwitch = privilegeSetLogin;
+const auto& headSwitch = privilegeSetLogin;
+const auto& patchSwitch = privilegeSetConfigureComponents;
+const auto& postSwitch = privilegeSetConfigureComponents;
+const auto& putSwitch = privilegeSetConfigureComponents;
+const auto& deleteSwitch = privilegeSetConfigureComponents;
+
+// SwitchCollection
+const auto& getSwitchCollection = privilegeSetLogin;
+const auto& headSwitchCollection = privilegeSetLogin;
+const auto& patchSwitchCollection = privilegeSetConfigureComponents;
+const auto& postSwitchCollection = privilegeSetConfigureComponents;
+const auto& putSwitchCollection = privilegeSetConfigureComponents;
+const auto& deleteSwitchCollection = privilegeSetConfigureComponents;
+
+// Task
+const auto& getTask = privilegeSetLogin;
+const auto& headTask = privilegeSetLogin;
+const auto& patchTask = privilegeSetConfigureManager;
+const auto& putTask = privilegeSetConfigureManager;
+const auto& deleteTask = privilegeSetConfigureManager;
+const auto& postTask = privilegeSetConfigureManager;
+
+// TaskCollection
+const auto& getTaskCollection = privilegeSetLogin;
+const auto& headTaskCollection = privilegeSetLogin;
+const auto& patchTaskCollection = privilegeSetConfigureManager;
+const auto& putTaskCollection = privilegeSetConfigureManager;
+const auto& deleteTaskCollection = privilegeSetConfigureManager;
+const auto& postTaskCollection = privilegeSetConfigureManager;
+
+// TaskService
+const auto& getTaskService = privilegeSetLogin;
+const auto& headTaskService = privilegeSetLogin;
+const auto& patchTaskService = privilegeSetConfigureManager;
+const auto& putTaskService = privilegeSetConfigureManager;
+const auto& deleteTaskService = privilegeSetConfigureManager;
+const auto& postTaskService = privilegeSetConfigureManager;
+
+// TelemetryService
+const auto& getTelemetryService = privilegeSetLogin;
+const auto& headTelemetryService = privilegeSetLogin;
+const auto& patchTelemetryService = privilegeSetConfigureManager;
+const auto& putTelemetryService = privilegeSetConfigureManager;
+const auto& deleteTelemetryService = privilegeSetConfigureManager;
+const auto& postTelemetryService = privilegeSetConfigureManager;
+
+// Thermal
+const auto& getThermal = privilegeSetLogin;
+const auto& headThermal = privilegeSetLogin;
+const auto& patchThermal = privilegeSetConfigureManager;
+const auto& putThermal = privilegeSetConfigureManager;
+const auto& deleteThermal = privilegeSetConfigureManager;
+const auto& postThermal = privilegeSetConfigureManager;
+
+// Triggers
+const auto& getTriggers = privilegeSetLogin;
+const auto& headTriggers = privilegeSetLogin;
+const auto& patchTriggers = privilegeSetConfigureManager;
+const auto& putTriggers = privilegeSetConfigureManager;
+const auto& deleteTriggers = privilegeSetConfigureManager;
+const auto& postTriggers = privilegeSetConfigureManager;
+
+// TriggersCollection
+const auto& getTriggersCollection = privilegeSetLogin;
+const auto& headTriggersCollection = privilegeSetLogin;
+const auto& patchTriggersCollection = privilegeSetConfigureManager;
+const auto& putTriggersCollection = privilegeSetConfigureManager;
+const auto& deleteTriggersCollection = privilegeSetConfigureManager;
+const auto& postTriggersCollection = privilegeSetConfigureManager;
+
+// UpdateService
+const auto& getUpdateService = privilegeSetLogin;
+const auto& headUpdateService = privilegeSetLogin;
+const auto& patchUpdateService = privilegeSetConfigureComponents;
+const auto& postUpdateService = privilegeSetConfigureComponents;
+const auto& putUpdateService = privilegeSetConfigureComponents;
+const auto& deleteUpdateService = privilegeSetConfigureComponents;
+
+// VCATEntry
+const auto& getVCATEntry = privilegeSetLogin;
+const auto& headVCATEntry = privilegeSetLogin;
+const auto& patchVCATEntry = privilegeSetConfigureComponents;
+const auto& putVCATEntry = privilegeSetConfigureComponents;
+const auto& deleteVCATEntry = privilegeSetConfigureComponents;
+const auto& postVCATEntry = privilegeSetConfigureComponents;
+
+// VCATEntryCollection
+const auto& getVCATEntryCollection = privilegeSetLogin;
+const auto& headVCATEntryCollection = privilegeSetLogin;
+const auto& patchVCATEntryCollection = privilegeSetConfigureComponents;
+const auto& putVCATEntryCollection = privilegeSetConfigureComponents;
+const auto& deleteVCATEntryCollection = privilegeSetConfigureComponents;
+const auto& postVCATEntryCollection = privilegeSetConfigureComponents;
+
+// VLanNetworkInterface
+const auto& getVLanNetworkInterface = privilegeSetLogin;
+const auto& headVLanNetworkInterface = privilegeSetLogin;
+const auto& patchVLanNetworkInterface = privilegeSetConfigureManager;
+const auto& putVLanNetworkInterface = privilegeSetConfigureManager;
+const auto& deleteVLanNetworkInterface = privilegeSetConfigureManager;
+const auto& postVLanNetworkInterface = privilegeSetConfigureManager;
+
+// VLanNetworkInterfaceCollection
+const auto& getVLanNetworkInterfaceCollection = privilegeSetLogin;
+const auto& headVLanNetworkInterfaceCollection = privilegeSetLogin;
+const auto& patchVLanNetworkInterfaceCollection = privilegeSetConfigureManager;
+const auto& putVLanNetworkInterfaceCollection = privilegeSetConfigureManager;
+const auto& deleteVLanNetworkInterfaceCollection = privilegeSetConfigureManager;
+const auto& postVLanNetworkInterfaceCollection = privilegeSetConfigureManager;
+
+// VirtualMedia
+const auto& getVirtualMedia = privilegeSetLogin;
+const auto& headVirtualMedia = privilegeSetLogin;
+const auto& patchVirtualMedia = privilegeSetConfigureManager;
+const auto& putVirtualMedia = privilegeSetConfigureManager;
+const auto& deleteVirtualMedia = privilegeSetConfigureManager;
+const auto& postVirtualMedia = privilegeSetConfigureManager;
+
+// VirtualMediaCollection
+const auto& getVirtualMediaCollection = privilegeSetLogin;
+const auto& headVirtualMediaCollection = privilegeSetLogin;
+const auto& patchVirtualMediaCollection = privilegeSetConfigureManager;
+const auto& putVirtualMediaCollection = privilegeSetConfigureManager;
+const auto& deleteVirtualMediaCollection = privilegeSetConfigureManager;
+const auto& postVirtualMediaCollection = privilegeSetConfigureManager;
+
+// Volume
+const auto& getVolume = privilegeSetLogin;
+const auto& headVolume = privilegeSetLogin;
+const auto& patchVolume = privilegeSetConfigureComponents;
+const auto& postVolume = privilegeSetConfigureComponents;
+const auto& putVolume = privilegeSetConfigureComponents;
+const auto& deleteVolume = privilegeSetConfigureComponents;
+
+// VolumeCollection
+const auto& getVolumeCollection = privilegeSetLogin;
+const auto& headVolumeCollection = privilegeSetLogin;
+const auto& patchVolumeCollection = privilegeSetConfigureComponents;
+const auto& postVolumeCollection = privilegeSetConfigureComponents;
+const auto& putVolumeCollection = privilegeSetConfigureComponents;
+const auto& deleteVolumeCollection = privilegeSetConfigureComponents;
+
+// Zone
+const auto& getZone = privilegeSetLogin;
+const auto& headZone = privilegeSetLogin;
+const auto& patchZone = privilegeSetConfigureComponents;
+const auto& postZone = privilegeSetConfigureComponents;
+const auto& putZone = privilegeSetConfigureComponents;
+const auto& deleteZone = privilegeSetConfigureComponents;
+
+// ZoneCollection
+const auto& getZoneCollection = privilegeSetLogin;
+const auto& headZoneCollection = privilegeSetLogin;
+const auto& patchZoneCollection = privilegeSetConfigureComponents;
+const auto& postZoneCollection = privilegeSetConfigureComponents;
+const auto& putZoneCollection = privilegeSetConfigureComponents;
+const auto& deleteZoneCollection = privilegeSetConfigureComponents;
+
+} // namespace redfish::privileges
diff --git a/redfish-core/lib/account_service.hpp b/redfish-core/lib/account_service.hpp
index 364d5e2..bce1853 100644
--- a/redfish-core/lib/account_service.hpp
+++ b/redfish-core/lib/account_service.hpp
@@ -20,6 +20,7 @@
 #include <error_messages.hpp>
 #include <openbmc_dbus_rest.hpp>
 #include <persistent_data.hpp>
+#include <registries/privilege_registry.hpp>
 #include <utils/json_utils.hpp>
 
 #include <variant>
@@ -1256,7 +1257,7 @@
 {
 
     BMCWEB_ROUTE(app, "/redfish/v1/AccountService/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getAccountService)
         .methods(
             boost::beast::http::verb::get)([](const crow::Request& req,
                                               const std::shared_ptr<
@@ -1375,7 +1376,7 @@
         });
 
     BMCWEB_ROUTE(app, "/redfish/v1/AccountService/Accounts/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getManagerAccountCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) -> void {
@@ -1447,7 +1448,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/AccountService/Accounts/")
-        .privileges({{"ConfigureUsers"}})
+        .privileges(redfish::privileges::postManagerAccountCollection)
         .methods(boost::beast::http::verb::post)([](const crow::Request& req,
                                                     const std::shared_ptr<
                                                         bmcweb::AsyncResp>&
@@ -1564,8 +1565,7 @@
         });
 
     BMCWEB_ROUTE(app, "/redfish/v1/AccountService/Accounts/<str>/")
-        .privileges(
-            {{"ConfigureUsers"}, {"ConfigureManager"}, {"ConfigureSelf"}})
+        .privileges(redfish::privileges::getManagerAccount)
         .methods(
             boost::beast::http::verb::
                 get)([](const crow::Request& req,
@@ -1723,6 +1723,9 @@
         });
 
     BMCWEB_ROUTE(app, "/redfish/v1/AccountService/Accounts/<str>/")
+        // TODO this privilege should be using the generated endpoints, but
+        // because of the special handling of ConfigureSelf, it's not able to
+        // yet
         .privileges({{"ConfigureUsers"}, {"ConfigureSelf"}})
         .methods(boost::beast::http::verb::patch)(
             [](const crow::Request& req,
@@ -1797,7 +1800,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/AccountService/Accounts/<str>/")
-        .privileges({{"ConfigureUsers"}})
+        .privileges(redfish::privileges::deleteManagerAccount)
         .methods(boost::beast::http::verb::delete_)(
             [](const crow::Request& /*req*/,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
diff --git a/redfish-core/lib/bios.hpp b/redfish-core/lib/bios.hpp
index 4ea0727..604b8e7 100644
--- a/redfish-core/lib/bios.hpp
+++ b/redfish-core/lib/bios.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <app.hpp>
+#include <registries/privilege_registry.hpp>
 #include <utils/fw_utils.hpp>
 namespace redfish
 {
@@ -10,7 +11,7 @@
 inline void requestRoutesBiosService(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/Bios/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getBios)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -41,6 +42,8 @@
 inline void requestRoutesBiosReset(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/Bios/Actions/Bios.ResetBios/")
+        // Incorrect Privilege;  Should be ConfigureComponents
+        //.privileges(redfish::privileges::postBios)
         .privileges({{"ConfigureManager"}})
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request&,
diff --git a/redfish-core/lib/certificate_service.hpp b/redfish-core/lib/certificate_service.hpp
index 6eb66c5..467b0fd 100644
--- a/redfish-core/lib/certificate_service.hpp
+++ b/redfish-core/lib/certificate_service.hpp
@@ -3,6 +3,7 @@
 #include <app.hpp>
 #include <boost/convert.hpp>
 #include <boost/convert/strtol.hpp>
+#include <registries/privilege_registry.hpp>
 
 #include <variant>
 namespace redfish
@@ -42,7 +43,7 @@
 inline void requestRoutesCertificateService(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/CertificateService/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getCertificateService)
         .methods(
             boost::beast::http::verb::
                 get)([](const crow::Request& req,
@@ -236,6 +237,8 @@
 {
     BMCWEB_ROUTE(app, "/redfish/v1/CertificateService/Actions/"
                       "CertificateService.GenerateCSR/")
+        // Incorrect Privilege;  Should be ConfigureManager
+        //.privileges(redfish::privileges::postCertificateService)
         .privileges({{"ConfigureComponents"}})
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
@@ -675,7 +678,7 @@
 {
     BMCWEB_ROUTE(app, "/redfish/v1/CertificateService/Actions/"
                       "CertificateService.ReplaceCertificate/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postCertificateService)
         .methods(
             boost::beast::http::verb::
                 post)([](const crow::Request& req,
@@ -793,7 +796,7 @@
     BMCWEB_ROUTE(
         app,
         "/redfish/v1/Managers/bmc/NetworkProtocol/HTTPS/Certificates/<str>/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::getCertificate)
         .methods(
             boost::beast::http::verb::
                 get)([](const crow::Request& req,
@@ -827,7 +830,7 @@
 {
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Managers/bmc/NetworkProtocol/HTTPS/Certificates/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::getCertificateCollection)
         .methods(
             boost::beast::http::verb::
                 get)([](const crow::Request&,
@@ -872,7 +875,7 @@
 
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Managers/bmc/NetworkProtocol/HTTPS/Certificates/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postCertificateCollection)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -979,7 +982,7 @@
 inline void requestRoutesCertificateLocations(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/CertificateService/CertificateLocations/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::getCertificateLocations)
         .methods(
             boost::beast::http::verb::
                 get)([](const crow::Request&,
@@ -1018,7 +1021,7 @@
 inline void requestRoutesLDAPCertificateCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/AccountService/LDAP/Certificates/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::getCertificateCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -1064,7 +1067,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/AccountService/LDAP/Certificates/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postCertificateCollection)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -1121,7 +1124,7 @@
 inline void requestRoutesLDAPCertificate(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/AccountService/LDAP/Certificates/<str>/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::getCertificate)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -1152,7 +1155,7 @@
 inline void requestRoutesTrustStoreCertificateCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/Truststore/Certificates/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::getCertificate)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -1196,7 +1199,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/Truststore/Certificates/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postCertificateCollection)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -1254,7 +1257,7 @@
 inline void requestRoutesTrustStoreCertificate(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/Truststore/Certificates/<str>/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::getCertificate)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -1280,7 +1283,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/Truststore/Certificates/<str>/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::deleteCertificate)
         .methods(boost::beast::http::verb::delete_)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
diff --git a/redfish-core/lib/chassis.hpp b/redfish-core/lib/chassis.hpp
index 8fa25f0..c41b7e1 100644
--- a/redfish-core/lib/chassis.hpp
+++ b/redfish-core/lib/chassis.hpp
@@ -20,6 +20,7 @@
 
 #include <app.hpp>
 #include <boost/container/flat_map.hpp>
+#include <registries/privilege_registry.hpp>
 #include <utils/collection.hpp>
 
 #include <variant>
@@ -162,7 +163,7 @@
 inline void requestRoutesChassisCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Chassis/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getChassisCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -185,7 +186,7 @@
 inline void requestRoutesChassis(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getChassis)
         .methods(
             boost::beast::http::verb::get)([](const crow::Request&,
                                               const std::shared_ptr<
@@ -443,7 +444,7 @@
         });
 
     BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/")
-        .privileges({{"ConfigureComponents"}})
+        .privileges(redfish::privileges::patchChassis)
         .methods(
             boost::beast::http::verb::
                 patch)([](const crow::Request& req,
@@ -642,7 +643,7 @@
 inline void requestRoutesChassisResetAction(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/Actions/Chassis.Reset/")
-        .privileges({{"ConfigureComponents"}})
+        .privileges(redfish::privileges::postChassis)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -677,7 +678,7 @@
 inline void requestRoutesChassisResetActionInfo(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/ResetActionInfo/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getActionInfo)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
diff --git a/redfish-core/lib/ethernet.hpp b/redfish-core/lib/ethernet.hpp
index 49aa3db..5141300 100644
--- a/redfish-core/lib/ethernet.hpp
+++ b/redfish-core/lib/ethernet.hpp
@@ -20,6 +20,7 @@
 #include <boost/container/flat_set.hpp>
 #include <dbus_singleton.hpp>
 #include <error_messages.hpp>
+#include <registries/privilege_registry.hpp>
 #include <utils/json_utils.hpp>
 
 #include <optional>
@@ -1829,7 +1830,7 @@
 inline void requestEthernetInterfacesRoutes(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getEthernetInterfaceCollection)
         .methods(
             boost::beast::http::verb::
                 get)([](const crow::Request&,
@@ -1878,7 +1879,7 @@
         });
 
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getEthernetInterface)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -1914,7 +1915,8 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/")
-        .privileges({{"ConfigureComponents"}})
+        .privileges(redfish::privileges::patchEthernetInterface)
+
         .methods(boost::beast::http::verb::patch)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -2064,7 +2066,8 @@
 
     BMCWEB_ROUTE(
         app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getVLanNetworkInterface)
+
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& /* req */,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -2106,6 +2109,8 @@
 
     BMCWEB_ROUTE(
         app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/<str>/")
+        // This privilege is incorrect, it should be ConfigureManager
+        //.privileges(redfish::privileges::patchVLanNetworkInterface)
         .privileges({{"ConfigureComponents"}})
         .methods(boost::beast::http::verb::patch)(
             [](const crow::Request& req,
@@ -2186,6 +2191,8 @@
 
     BMCWEB_ROUTE(
         app, "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/<str>/")
+        // This privilege is incorrect, it should be ConfigureManager
+        //.privileges(redfish::privileges::deleteVLanNetworkInterface)
         .privileges({{"ConfigureComponents"}})
         .methods(boost::beast::http::verb::delete_)(
             [](const crow::Request& /* req */,
@@ -2238,7 +2245,8 @@
 
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/")
-        .privileges({{"Login"}})
+
+        .privileges(redfish::privileges::getVLanNetworkInterfaceCollection)
         .methods(
             boost::beast::http::verb::
                 get)([](const crow::Request& /* req */,
@@ -2296,6 +2304,8 @@
 
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Managers/bmc/EthernetInterfaces/<str>/VLANs/")
+        // This privilege is wrong, it should be ConfigureManager
+        //.privileges(redfish::privileges::postVLanNetworkInterfaceCollection)
         .privileges({{"ConfigureComponents"}})
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
diff --git a/redfish-core/lib/event_service.hpp b/redfish-core/lib/event_service.hpp
index bd11751..1330438 100644
--- a/redfish-core/lib/event_service.hpp
+++ b/redfish-core/lib/event_service.hpp
@@ -17,6 +17,8 @@
 #include "event_service_manager.hpp"
 
 #include <app.hpp>
+#include <registries/privilege_registry.hpp>
+
 namespace redfish
 {
 
@@ -40,7 +42,7 @@
 inline void requestRoutesEventService(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/EventService/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getEventService)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -83,7 +85,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/EventService/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::patchEventService)
         .methods(boost::beast::http::verb::patch)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
@@ -149,7 +151,7 @@
 
     BMCWEB_ROUTE(
         app, "/redfish/v1/EventService/Actions/EventService.SubmitTestEvent/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postEventService)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -161,7 +163,7 @@
 inline void requestRoutesEventDestinationCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/EventService/Subscriptions")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getEventDestinationCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -188,6 +190,9 @@
                 }
             });
     BMCWEB_ROUTE(app, "/redfish/v1/EventService/Subscriptions/")
+        // The below privilege is wrong, it should be ConfigureManager OR
+        // ConfigureComponents
+        //.privileges(redfish::privileges::postEventDestinationCollection)
         .privileges({{"ConfigureManager"}})
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
@@ -483,8 +488,8 @@
 
 inline void requestRoutesEventDestination(App& app)
 {
-    BMCWEB_ROUTE(app, "/redfish/v1/EventService/Subscriptions/<str>/")
-        .privileges({{"Login"}})
+    BMCWEB_ROUTE(app, "redfish/v1/EventService/Subscriptions/<str>/")
+        .privileges(redfish::privileges::getEventDestination)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -535,7 +540,11 @@
             });
     /////redfish/v1/EventService/Subscriptions/
     // ConfigureManager
-    BMCWEB_ROUTE(app, "/redfish/v1/EventService/Subscriptions/<str>/")
+    BMCWEB_ROUTE(app, "redfish/v1/EventService/Subscriptions/<str>/")
+        // The below privilege is wrong, it should be ConfigureManager OR
+        // ConfigureSelf
+        // TODO(ed) follow up with DMTF spec and understand ConfigureSelf
+        //.privileges(redfish::privileges::patchEventDestination)
         .privileges({{"ConfigureManager"}})
         .methods(boost::beast::http::verb::patch)(
             [](const crow::Request& req,
@@ -588,7 +597,10 @@
 
                 EventServiceManager::getInstance().updateSubscriptionData();
             });
-    BMCWEB_ROUTE(app, "/redfish/v1/EventService/Subscriptions/<str>/")
+    BMCWEB_ROUTE(app, "redfish/v1/EventService/Subscriptions/<str>/")
+        // The below privilege is wrong, it should be ConfigureManager OR
+        // ConfigureSelf
+        //.privileges(redfish::privileges::deleteEventDestination)
         .privileges({{"ConfigureManager"}})
         .methods(boost::beast::http::verb::delete_)(
             [](const crow::Request&,
diff --git a/redfish-core/lib/hypervisor_system.hpp b/redfish-core/lib/hypervisor_system.hpp
index 5274e53..79a89fa 100644
--- a/redfish-core/lib/hypervisor_system.hpp
+++ b/redfish-core/lib/hypervisor_system.hpp
@@ -5,6 +5,7 @@
 #include <boost/container/flat_set.hpp>
 #include <dbus_singleton.hpp>
 #include <error_messages.hpp>
+#include <registries/privilege_registry.hpp>
 #include <utils/json_utils.hpp>
 
 #include <optional>
@@ -725,7 +726,7 @@
      */
 
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/hypervisor/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getComputerSystem)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -769,7 +770,7 @@
      */
 
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/hypervisor/EthernetInterfaces/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getEthernetInterfaceCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -825,7 +826,7 @@
 
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Systems/hypervisor/EthernetInterfaces/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getEthernetInterface)
         .methods(
             boost::beast::http::verb::get)([](const crow::Request&,
                                               const std::shared_ptr<
@@ -856,7 +857,7 @@
 
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Systems/hypervisor/EthernetInterfaces/<str>/")
-        .privileges({{"ConfigureComponents"}})
+        .privileges(redfish::privileges::patchEthernetInterface)
         .methods(
             boost::beast::http::verb::
                 patch)([](const crow::Request& req,
@@ -970,7 +971,7 @@
         });
 
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/hypervisor/ResetActionInfo/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getActionInfo)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -1029,7 +1030,7 @@
 
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Systems/hypervisor/Actions/ComputerSystem.Reset/")
-        .privileges({{"ConfigureComponents"}})
+        .privileges(redfish::privileges::postComputerSystem)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
diff --git a/redfish-core/lib/log_services.hpp b/redfish-core/lib/log_services.hpp
index 31f046e..b5fb066 100644
--- a/redfish-core/lib/log_services.hpp
+++ b/redfish-core/lib/log_services.hpp
@@ -31,6 +31,7 @@
 #include <boost/container/flat_map.hpp>
 #include <boost/system/linux_error.hpp>
 #include <error_messages.hpp>
+#include <registries/privilege_registry.hpp>
 
 #include <filesystem>
 #include <optional>
@@ -908,7 +909,7 @@
      * Functions triggers appropriate requests on DBus
      */
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogServiceCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
@@ -979,7 +980,7 @@
 inline void requestRoutesEventLogService(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/EventLog/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogService)
         .methods(
             boost::beast::http::verb::
                 get)([](const crow::Request&,
@@ -1150,7 +1151,7 @@
 {
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Systems/system/LogServices/EventLog/Entries/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogEntry)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -1244,7 +1245,7 @@
 {
     BMCWEB_ROUTE(
         app, "/redfish/v1/Systems/system/LogServices/EventLog/Entries/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogEntry)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -1305,7 +1306,7 @@
 {
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Systems/system/LogServices/EventLog/Entries/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogEntryCollection)
         .methods(
             boost::beast::http::verb::
                 get)([](const crow::Request&,
@@ -1478,7 +1479,7 @@
 {
     BMCWEB_ROUTE(
         app, "/redfish/v1/Systems/system/LogServices/EventLog/Entries/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogEntry)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -1609,7 +1610,7 @@
 
     BMCWEB_ROUTE(
         app, "/redfish/v1/Systems/system/LogServices/EventLog/Entries/<str>/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::patchLogEntry)
         .methods(boost::beast::http::verb::patch)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -1642,7 +1643,8 @@
 
     BMCWEB_ROUTE(
         app, "/redfish/v1/Systems/system/LogServices/EventLog/Entries/<str>/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::deleteLogEntry)
+
         .methods(boost::beast::http::verb::delete_)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -1692,7 +1694,7 @@
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/EventLog/Entries/"
                       "<str>/attachment")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogEntry)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -1802,7 +1804,7 @@
 inline void requestRoutesBMCLogServiceCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogService)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -1837,7 +1839,7 @@
 inline void requestRoutesBMCJournalLogService(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Journal/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogService)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
@@ -1931,7 +1933,7 @@
 inline void requestRoutesBMCJournalLogEntryCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogEntryCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -2021,7 +2023,7 @@
 {
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogEntry)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -2090,7 +2092,7 @@
 inline void requestRoutesBMCDumpService(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Dump/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogService)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -2130,7 +2132,7 @@
      * Functions triggers appropriate requests on DBus
      */
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogEntryCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -2150,7 +2152,7 @@
 {
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogEntry)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -2159,7 +2161,7 @@
             });
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/<str>/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::deleteLogEntry)
         .methods(boost::beast::http::verb::delete_)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -2174,7 +2176,7 @@
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Dump/"
                       "Actions/"
                       "LogService.CollectDiagnosticData/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postLogService)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -2187,7 +2189,7 @@
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Dump/"
                       "Actions/"
                       "LogService.ClearLog/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postLogService)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -2198,7 +2200,7 @@
 inline void requestRoutesSystemDumpService(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/Dump/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogService)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
@@ -2242,8 +2244,8 @@
     /**
      * Functions triggers appropriate requests on DBus
      */
-    BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/Dump/Entries/")
-        .privileges({{"Login"}})
+    BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/")
+        .privileges(redfish::privileges::getLogEntryCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -2263,7 +2265,8 @@
 {
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Systems/system/LogServices/Dump/Entries/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogEntry)
+
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -2273,7 +2276,7 @@
 
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Systems/system/LogServices/Dump/Entries/<str>/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::deleteLogEntry)
         .methods(boost::beast::http::verb::delete_)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -2287,7 +2290,7 @@
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/Dump/"
                       "Actions/"
                       "LogService.CollectDiagnosticData/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postLogService)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
@@ -2300,7 +2303,7 @@
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/Dump/"
                       "Actions/"
                       "LogService.ClearLog/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postLogService)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
@@ -2316,6 +2319,8 @@
      * Functions triggers appropriate requests on DBus
      */
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/Crashdump/")
+        // This is incorrect, should be:
+        //.privileges(redfish::privileges::getLogService)
         .privileges({{"ConfigureManager"}})
         .methods(
             boost::beast::http::verb::
@@ -2357,6 +2362,8 @@
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Systems/system/LogServices/Crashdump/Actions/"
                  "LogService.ClearLog/")
+        // This is incorrect, should be:
+        //.privileges(redfish::privileges::postLogService)
         .privileges({{"ConfigureComponents"}})
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request&,
@@ -2441,6 +2448,8 @@
      */
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/")
+        // This is incorrect, should be.
+        //.privileges(redfish::privileges::postLogEntryCollection)
         .privileges({{"ConfigureComponents"}})
         .methods(
             boost::beast::http::verb::
@@ -2515,6 +2524,8 @@
 
     BMCWEB_ROUTE(
         app, "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/<str>/")
+        // this is incorrect, should be
+        // .privileges(redfish::privileges::getLogEntry)
         .privileges({{"ConfigureComponents"}})
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
@@ -2532,7 +2543,7 @@
     BMCWEB_ROUTE(
         app,
         "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/<str>/<str>/")
-        .privileges({{"ConfigureComponents"}})
+        .privileges(redfish::privileges::getLogEntry)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -2619,6 +2630,8 @@
     // method for security reasons.
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/Crashdump/"
                       "Actions/LogService.CollectDiagnosticData/")
+        // The below is incorrect;  Should be ConfigureManager
+        //.privileges(redfish::privileges::postLogService)
         .privileges({{"ConfigureComponents"}})
         .methods(
             boost::beast::http::verb::
@@ -2729,7 +2742,7 @@
 
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/EventLog/Actions/"
                       "LogService.ClearLog/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postLogService)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -2769,7 +2782,7 @@
 inline void requestRoutesPostCodesLogService(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/PostCodes/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogService)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -2804,6 +2817,8 @@
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Systems/system/LogServices/PostCodes/Actions/"
                  "LogService.ClearLog/")
+        // The following privilege is incorrect;  It should be ConfigureManager
+        //.privileges(redfish::privileges::postLogService)
         .privileges({{"ConfigureComponents"}})
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request&,
@@ -3076,7 +3091,7 @@
 {
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Systems/system/LogServices/PostCodes/Entries/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogEntryCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -3108,7 +3123,7 @@
 {
     BMCWEB_ROUTE(
         app, "/redfish/v1/Systems/system/LogServices/PostCodes/Entries/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getLogEntry)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
diff --git a/redfish-core/lib/managers.hpp b/redfish-core/lib/managers.hpp
index c6e6019..344ca83 100644
--- a/redfish-core/lib/managers.hpp
+++ b/redfish-core/lib/managers.hpp
@@ -22,6 +22,7 @@
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/date_time.hpp>
 #include <dbus_utility.hpp>
+#include <registries/privilege_registry.hpp>
 #include <utils/fw_utils.hpp>
 #include <utils/systemd_utils.hpp>
 
@@ -109,7 +110,7 @@
      */
 
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/Actions/Manager.Reset/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postManager)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -165,7 +166,7 @@
 
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Managers/bmc/Actions/Manager.ResetToDefaults/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postManager)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -224,7 +225,7 @@
      */
 
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/ResetActionInfo/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getActionInfo)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -1923,7 +1924,7 @@
     std::string uuid = persistent_data::getConfig().systemUuid;
 
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getManager)
         .methods(boost::beast::http::verb::get)([uuid](const crow::Request&,
                                                        const std::shared_ptr<
                                                            bmcweb::AsyncResp>&
@@ -2187,7 +2188,7 @@
         });
 
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::patchManager)
         .methods(
             boost::beast::http::verb::
                 patch)([](const crow::Request& req,
@@ -2270,7 +2271,7 @@
 inline void requestRoutesManagerCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getManagerCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
diff --git a/redfish-core/lib/memory.hpp b/redfish-core/lib/memory.hpp
index 377d730..62d5933 100644
--- a/redfish-core/lib/memory.hpp
+++ b/redfish-core/lib/memory.hpp
@@ -20,6 +20,7 @@
 #include <app.hpp>
 #include <boost/container/flat_map.hpp>
 #include <boost/format.hpp>
+#include <registries/privilege_registry.hpp>
 #include <utils/collection.hpp>
 #include <utils/json_utils.hpp>
 
@@ -886,7 +887,7 @@
      * Functions triggers appropriate requests on DBus
      */
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/Memory/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getMemoryCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -908,7 +909,7 @@
      * Functions triggers appropriate requests on DBus
      */
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/Memory/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getMemory)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
diff --git a/redfish-core/lib/message_registries.hpp b/redfish-core/lib/message_registries.hpp
index ae1358e..e3bd5bf 100644
--- a/redfish-core/lib/message_registries.hpp
+++ b/redfish-core/lib/message_registries.hpp
@@ -22,6 +22,7 @@
 #include "registries/task_event_message_registry.hpp"
 
 #include <app.hpp>
+#include <registries/privilege_registry.hpp>
 
 namespace redfish
 {
@@ -32,7 +33,7 @@
      * Functions triggers appropriate requests on DBus
      */
     BMCWEB_ROUTE(app, "/redfish/v1/Registries/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getMessageRegistryFileCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -57,7 +58,7 @@
 inline void requestRoutesMessageRegistryFile(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Registries/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getMessageRegistryFile)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -123,7 +124,7 @@
 inline void requestRoutesMessageRegistry(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Registries/<str>/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getMessageRegistryFile)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
diff --git a/redfish-core/lib/metric_report.hpp b/redfish-core/lib/metric_report.hpp
index 66f4f93..63c8c19 100644
--- a/redfish-core/lib/metric_report.hpp
+++ b/redfish-core/lib/metric_report.hpp
@@ -3,6 +3,7 @@
 #include "utils/telemetry_utils.hpp"
 
 #include <app.hpp>
+#include <registries/privilege_registry.hpp>
 
 namespace redfish
 {
@@ -63,7 +64,7 @@
 inline void requestRoutesMetricReportCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/TelemetryService/MetricReports/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getMetricReportCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -81,7 +82,7 @@
 inline void requestRoutesMetricReport(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/TelemetryService/MetricReports/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getMetricReport)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
diff --git a/redfish-core/lib/metric_report_definition.hpp b/redfish-core/lib/metric_report_definition.hpp
index 76ff2b2..a0c4f1d 100644
--- a/redfish-core/lib/metric_report_definition.hpp
+++ b/redfish-core/lib/metric_report_definition.hpp
@@ -6,6 +6,7 @@
 
 #include <app.hpp>
 #include <boost/container/flat_map.hpp>
+#include <registries/privilege_registry.hpp>
 
 #include <tuple>
 #include <variant>
@@ -350,7 +351,7 @@
 inline void requestRoutesMetricReportDefinitionCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/TelemetryService/MetricReportDefinitions/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getMetricReportDefinitionCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -367,7 +368,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/TelemetryService/MetricReportDefinitions/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postMetricReportDefinitionCollection)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -413,7 +414,7 @@
 {
     BMCWEB_ROUTE(app,
                  "/redfish/v1/TelemetryService/MetricReportDefinitions/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getMetricReportDefinition)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -447,7 +448,7 @@
             });
     BMCWEB_ROUTE(app,
                  "/redfish/v1/TelemetryService/MetricReportDefinitions/<str>/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::deleteMetricReportDefinitionCollection)
         .methods(boost::beast::http::verb::delete_)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
diff --git a/redfish-core/lib/network_protocol.hpp b/redfish-core/lib/network_protocol.hpp
index daa1965..b74513b 100644
--- a/redfish-core/lib/network_protocol.hpp
+++ b/redfish-core/lib/network_protocol.hpp
@@ -19,6 +19,7 @@
 #include "openbmc_dbus_rest.hpp"
 
 #include <app.hpp>
+#include <registries/privilege_registry.hpp>
 #include <utils/json_utils.hpp>
 
 #include <optional>
@@ -458,7 +459,7 @@
 inline void requestRoutesNetworkProtocol(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/NetworkProtocol/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::patchManagerNetworkProtocol)
         .methods(boost::beast::http::verb::patch)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -550,7 +551,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/NetworkProtocol/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getManagerNetworkProtocol)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
diff --git a/redfish-core/lib/pcie.hpp b/redfish-core/lib/pcie.hpp
index daff5c0..e534434 100644
--- a/redfish-core/lib/pcie.hpp
+++ b/redfish-core/lib/pcie.hpp
@@ -18,6 +18,7 @@
 
 #include <app.hpp>
 #include <boost/system/linux_error.hpp>
+#include <registries/privilege_registry.hpp>
 
 namespace redfish
 {
@@ -75,7 +76,7 @@
      * Functions triggers appropriate requests on DBus
      */
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/PCIeDevices/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getPCIeDeviceCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
@@ -96,7 +97,7 @@
 inline void requestRoutesSystemPCIeDevice(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/PCIeDevices/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getPCIeDevice)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -170,7 +171,7 @@
      */
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Systems/system/PCIeDevices/<str>/PCIeFunctions/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getPCIeFunctionCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -251,7 +252,7 @@
     BMCWEB_ROUTE(
         app,
         "/redfish/v1/Systems/system/PCIeDevices/<str>/PCIeFunctions/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getPCIeFunction)
         .methods(
             boost::beast::http::verb::get)([](const crow::Request&,
                                               const std::shared_ptr<
diff --git a/redfish-core/lib/power.hpp b/redfish-core/lib/power.hpp
index c2a9945..3a024d3 100644
--- a/redfish-core/lib/power.hpp
+++ b/redfish-core/lib/power.hpp
@@ -19,6 +19,7 @@
 #include "sensors.hpp"
 
 #include <app.hpp>
+#include <registries/privilege_registry.hpp>
 
 namespace redfish
 {
@@ -128,7 +129,7 @@
 {
 
     BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/Power/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getPower)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -319,7 +320,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/Power/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::patchPower)
         .methods(boost::beast::http::verb::patch)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
diff --git a/redfish-core/lib/processor.hpp b/redfish-core/lib/processor.hpp
index 8111717..7f973cf 100644
--- a/redfish-core/lib/processor.hpp
+++ b/redfish-core/lib/processor.hpp
@@ -19,6 +19,7 @@
 
 #include <app.hpp>
 #include <boost/container/flat_map.hpp>
+#include <registries/privilege_registry.hpp>
 #include <sdbusplus/message/native_types.hpp>
 #include <sdbusplus/utility/dedup_variant.hpp>
 #include <utils/collection.hpp>
@@ -1066,7 +1067,7 @@
 
     BMCWEB_ROUTE(
         app, "/redfish/v1/Systems/system/Processors/<str>/OperatingConfigs/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getOperatingConfigCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -1129,7 +1130,7 @@
     BMCWEB_ROUTE(
         app,
         "/redfish/v1/Systems/system/Processors/<str>/OperatingConfigs/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getOperatingConfig)
         .methods(
             boost::beast::http::verb::get)([](const crow::Request& req,
                                               const std::shared_ptr<
@@ -1192,7 +1193,7 @@
      * Functions triggers appropriate requests on DBus
      */
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/Processors/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getProcessorCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -1217,7 +1218,7 @@
      */
 
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/Processors/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getProcessor)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -1231,7 +1232,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/Processors/<str>/")
-        .privileges({{"ConfigureComponents"}})
+        .privileges(redfish::privileges::patchProcessor)
         .methods(boost::beast::http::verb::patch)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
diff --git a/redfish-core/lib/redfish_sessions.hpp b/redfish-core/lib/redfish_sessions.hpp
index bb7ad12..472151a 100644
--- a/redfish-core/lib/redfish_sessions.hpp
+++ b/redfish-core/lib/redfish_sessions.hpp
@@ -19,6 +19,7 @@
 #include "persistent_data.hpp"
 
 #include <app.hpp>
+#include <registries/privilege_registry.hpp>
 
 namespace redfish
 {
@@ -46,7 +47,7 @@
 inline void requestRoutesSession(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/SessionService/Sessions/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getSession)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& /*req*/,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -66,7 +67,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/SessionService/Sessions/<str>/")
-        .privileges({{"ConfigureManager"}, {"ConfigureSelf"}})
+        .privileges(redfish::privileges::deleteSession)
         .methods(boost::beast::http::verb::delete_)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -105,7 +106,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/SessionService/Sessions/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getSessionCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& /*req*/,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) -> void {
@@ -133,6 +134,11 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/SessionService/Sessions/")
+        // Note, this technically doesn't match the privilege registry given the
+        // way login mechanisms work.  The base privilege registry lists this
+        // endpoint as requiring login privilege, but because this is the
+        // endpoint responsible for giving the login privilege, and it is itself
+        // its own route, it needs to not require Login
         .privileges({})
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
@@ -214,7 +220,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/SessionService/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getSessionService)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& /* req */,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) -> void {
@@ -235,7 +241,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/SessionService/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::patchSessionService)
         .methods(boost::beast::http::verb::patch)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) -> void {
diff --git a/redfish-core/lib/roles.hpp b/redfish-core/lib/roles.hpp
index 90b8de3..8f14b2e 100644
--- a/redfish-core/lib/roles.hpp
+++ b/redfish-core/lib/roles.hpp
@@ -16,6 +16,7 @@
 #pragma once
 
 #include <app.hpp>
+#include <registries/privilege_registry.hpp>
 
 #include <variant>
 
@@ -73,7 +74,7 @@
 inline void requestRoutesRoles(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/AccountService/Roles/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getRole)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -102,7 +103,7 @@
 inline void requestRoutesRoleCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/AccountService/Roles/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getRoleCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
diff --git a/redfish-core/lib/sensors.hpp b/redfish-core/lib/sensors.hpp
index 0566e93..d986565 100644
--- a/redfish-core/lib/sensors.hpp
+++ b/redfish-core/lib/sensors.hpp
@@ -21,6 +21,7 @@
 #include <boost/container/flat_map.hpp>
 #include <boost/range/algorithm/replace_copy_if.hpp>
 #include <dbus_singleton.hpp>
+#include <registries/privilege_registry.hpp>
 #include <utils/json_utils.hpp>
 
 #include <cmath>
@@ -2978,7 +2979,7 @@
 inline void requestRoutesSensorCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/Sensors/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getSensorCollection)
         .methods(
             boost::beast::http::verb::get)([](const crow::Request&,
                                               const std::shared_ptr<
@@ -3034,7 +3035,7 @@
 inline void requestRoutesSensor(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/Sensors/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getSensor)
         .methods(
             boost::beast::http::verb::get)([](const crow::Request&,
                                               const std::shared_ptr<
diff --git a/redfish-core/lib/service_root.hpp b/redfish-core/lib/service_root.hpp
index efc3fed..6778141 100644
--- a/redfish-core/lib/service_root.hpp
+++ b/redfish-core/lib/service_root.hpp
@@ -16,6 +16,7 @@
 #pragma once
 
 #include <app.hpp>
+#include <registries/privilege_registry.hpp>
 #include <utils/systemd_utils.hpp>
 
 namespace redfish
@@ -25,7 +26,7 @@
 {
     std::string uuid = persistent_data::getConfig().systemUuid;
     BMCWEB_ROUTE(app, "/redfish/v1/")
-        .privileges({})
+        .privileges(redfish::privileges::getServiceRoot)
         .methods(boost::beast::http::verb::get)(
             [uuid](const crow::Request&,
                    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
diff --git a/redfish-core/lib/storage.hpp b/redfish-core/lib/storage.hpp
index 0a1d4e6..a48ef8c 100644
--- a/redfish-core/lib/storage.hpp
+++ b/redfish-core/lib/storage.hpp
@@ -19,13 +19,14 @@
 #include "openbmc_dbus_rest.hpp"
 
 #include <app.hpp>
+#include <registries/privilege_registry.hpp>
 
 namespace redfish
 {
 inline void requestRoutesStorageCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/Storage/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getStorageCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -43,7 +44,7 @@
 inline void requestRoutesStorage(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/Storage/1/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getStorage)
         .methods(
             boost::beast::http::verb::
                 get)([](const crow::Request&,
@@ -266,7 +267,7 @@
 inline void requestRoutesDrive(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/Storage/1/Drives/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getDrive)
         .methods(
             boost::beast::http::verb::get)([](const crow::Request&,
                                               const std::shared_ptr<
diff --git a/redfish-core/lib/systems.hpp b/redfish-core/lib/systems.hpp
index 3e7b4739..2b9636f 100644
--- a/redfish-core/lib/systems.hpp
+++ b/redfish-core/lib/systems.hpp
@@ -22,6 +22,7 @@
 
 #include <app.hpp>
 #include <boost/container/flat_map.hpp>
+#include <registries/privilege_registry.hpp>
 #include <utils/fw_utils.hpp>
 #include <utils/json_utils.hpp>
 
@@ -2220,7 +2221,7 @@
 inline void requestRoutesSystemsCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getComputerSystemCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -2294,7 +2295,7 @@
      */
     BMCWEB_ROUTE(app,
                  "/redfish/v1/Systems/system/Actions/ComputerSystem.Reset/")
-        .privileges({{"ConfigureComponent"}})
+        .privileges(redfish::privileges::postComputerSystem)
         .methods(
             boost::beast::http::verb::
                 post)([](const crow::Request& req,
@@ -2421,7 +2422,7 @@
      * Functions triggers appropriate requests on DBus
      */
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getComputerSystem)
         .methods(
             boost::beast::http::verb::
                 get)([](const crow::Request&,
@@ -2542,7 +2543,7 @@
             getPowerMode(asyncResp);
         });
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/")
-        .privileges({{"ConfigureComponent"}})
+        .privileges(redfish::privileges::patchComputerSystem)
         .methods(boost::beast::http::verb::patch)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -2651,7 +2652,7 @@
      * Functions triggers appropriate requests on DBus
      */
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/ResetActionInfo/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getActionInfo)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
diff --git a/redfish-core/lib/task.hpp b/redfish-core/lib/task.hpp
index bca25a1..22e9743 100644
--- a/redfish-core/lib/task.hpp
+++ b/redfish-core/lib/task.hpp
@@ -19,6 +19,7 @@
 #include <boost/asio/post.hpp>
 #include <boost/asio/steady_timer.hpp>
 #include <boost/container/flat_map.hpp>
+#include <registries/privilege_registry.hpp>
 #include <task_messages.hpp>
 
 #include <chrono>
@@ -316,7 +317,7 @@
 inline void requestRoutesTaskMonitor(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/TaskService/Tasks/<str>/Monitor/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getTask)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -355,7 +356,7 @@
 inline void requestRoutesTask(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/TaskService/Tasks/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getTask)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -423,7 +424,7 @@
 inline void requestRoutesTaskCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/TaskService/Tasks/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getTaskCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -453,7 +454,7 @@
 inline void requestRoutesTaskService(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/TaskService/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getTaskService)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
diff --git a/redfish-core/lib/telemetry_service.hpp b/redfish-core/lib/telemetry_service.hpp
index 2ab69b9..ad86d5c 100644
--- a/redfish-core/lib/telemetry_service.hpp
+++ b/redfish-core/lib/telemetry_service.hpp
@@ -3,6 +3,7 @@
 #include "utils/telemetry_utils.hpp"
 
 #include <app.hpp>
+#include <registries/privilege_registry.hpp>
 
 #include <variant>
 
@@ -12,7 +13,7 @@
 inline void requestRoutesTelemetryService(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/TelemetryService/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getTelemetryService)
         .methods(
             boost::beast::http::verb::
                 get)([](const crow::Request&,
diff --git a/redfish-core/lib/thermal.hpp b/redfish-core/lib/thermal.hpp
index 90f04e8..feb78a0 100644
--- a/redfish-core/lib/thermal.hpp
+++ b/redfish-core/lib/thermal.hpp
@@ -18,6 +18,7 @@
 #include "sensors.hpp"
 
 #include <app.hpp>
+#include <registries/privilege_registry.hpp>
 
 namespace redfish
 {
@@ -25,7 +26,7 @@
 inline void requestRoutesThermal(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/Thermal/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getThermal)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -47,7 +48,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/Thermal/")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::patchThermal)
         .methods(boost::beast::http::verb::patch)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
diff --git a/redfish-core/lib/update_service.hpp b/redfish-core/lib/update_service.hpp
index 33747dd..663d48b 100644
--- a/redfish-core/lib/update_service.hpp
+++ b/redfish-core/lib/update_service.hpp
@@ -19,6 +19,7 @@
 
 #include <app.hpp>
 #include <boost/container/flat_map.hpp>
+#include <registries/privilege_registry.hpp>
 #include <utils/fw_utils.hpp>
 
 #include <variant>
@@ -388,7 +389,7 @@
 {
     BMCWEB_ROUTE(
         app, "/redfish/v1/UpdateService/Actions/UpdateService.SimpleUpdate/")
-        .privileges({{"ConfigureComponents"}})
+        .privileges(redfish::privileges::postUpdateService)
         .methods(
             boost::beast::http::verb::
                 post)([](const crow::Request& req,
@@ -507,7 +508,7 @@
 inline void requestRoutesUpdateService(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getUpdateService)
         .methods(
             boost::beast::http::verb::
                 get)([](const crow::Request&,
@@ -579,7 +580,7 @@
                 "xyz.openbmc_project.Software.ApplyTime", "RequestedApplyTime");
         });
     BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/")
-        .privileges({{"ConfigureComponents"}})
+        .privileges(redfish::privileges::patchUpdateService)
         .methods(boost::beast::http::verb::patch)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -661,7 +662,7 @@
                 }
             });
     BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/")
-        .privileges({{"ConfigureComponents"}})
+        .privileges(redfish::privileges::postUpdateService)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -687,7 +688,7 @@
 inline void requestRoutesSoftwareInventoryCollection(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/FirmwareInventory/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getSoftwareInventoryCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request&,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
@@ -776,7 +777,7 @@
 inline void requestRoutesSoftwareInventory(App& app)
 {
     BMCWEB_ROUTE(app, "/redfish/v1/UpdateService/FirmwareInventory/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getSoftwareInventory)
         .methods(
             boost::beast::http::verb::get)([](const crow::Request&,
                                               const std::shared_ptr<
diff --git a/redfish-core/lib/virtual_media.hpp b/redfish-core/lib/virtual_media.hpp
index 8fe31d5..6e69f20 100644
--- a/redfish-core/lib/virtual_media.hpp
+++ b/redfish-core/lib/virtual_media.hpp
@@ -21,8 +21,10 @@
 #include <boost/type_traits/has_dereference.hpp>
 #include <utils/json_utils.hpp>
 // for GetObjectType and ManagedObjectType
+
 #include <account_service.hpp>
 #include <boost/url/url_view.hpp>
+#include <registries/privilege_registry.hpp>
 
 namespace redfish
 {
@@ -775,7 +777,7 @@
 {
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/VirtualMedia/<str>/Actions/"
                       "VirtualMedia.InsertMedia")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postVirtualMedia)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -920,7 +922,7 @@
 
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/VirtualMedia/<str>/Actions/"
                       "VirtualMedia.EjectMedia")
-        .privileges({{"ConfigureManager"}})
+        .privileges(redfish::privileges::postVirtualMedia)
         .methods(boost::beast::http::verb::post)(
             [](const crow::Request& req,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -1010,7 +1012,7 @@
                     std::array<const char*, 0>());
             });
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/VirtualMedia/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getVirtualMediaCollection)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& /* req */,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
@@ -1054,7 +1056,7 @@
             });
 
     BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/VirtualMedia/<str>/")
-        .privileges({{"Login"}})
+        .privileges(redfish::privileges::getVirtualMedia)
         .methods(boost::beast::http::verb::get)(
             [](const crow::Request& /* req */,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
diff --git a/scripts/parse_registries.py b/scripts/parse_registries.py
index 05fc62d..a94fc04 100755
--- a/scripts/parse_registries.py
+++ b/scripts/parse_registries.py
@@ -63,6 +63,10 @@
     return (path, json_file, type_name, url)
 
 
+def clang_format(filename):
+    subprocess.check_call(["clang-format-11", "-i", filename])
+
+
 files = []
 files.append(make_getter('Base.1.10.0.json',
                          'base_message_registry.hpp', 'base'))
@@ -115,4 +119,73 @@
             registry.write("\"{}\",".format(message["Resolution"]))
             registry.write("}},")
         registry.write("};}\n")
-    subprocess.check_call(["clang-format-11", "-i", file])
+    clang_format(file)
+
+
+def get_privilege_string_from_list(privilege_list):
+    privilege_string = "{{\n"
+    for privilege_json in privilege_list:
+        privileges = privilege_json["Privilege"]
+        privilege_string += "    {"
+        for privilege in privileges:
+            if privilege == "NoAuth":
+                continue
+            privilege_string += "\""
+            privilege_string += privilege
+            privilege_string += "\",\n"
+        if privilege != "NoAuth":
+            privilege_string = privilege_string[:-2]
+        privilege_string += "}"
+        privilege_string += ",\n"
+    privilege_string = privilege_string[:-2]
+    privilege_string += "\n}}"
+    return privilege_string
+
+def get_variable_name_for_privilege_set(privilege_list):
+    names = []
+    for privilege_json in privilege_list:
+        privileges = privilege_json["Privilege"]
+        names.append("And".join(privileges))
+    return "Or".join(names)
+
+def make_privilege_registry():
+    path, json_file, type_name, url = make_getter('Redfish_1.1.0_PrivilegeRegistry.json',
+                                                  'privilege_registry.hpp', 'privilege')
+    with open(path, 'w') as registry:
+        registry.write("#pragma once\n")
+        registry.write("//{} is generated.  Do not edit directly\n".format(os.path.basename(path)))
+
+        registry.write("#include <privileges.hpp>\n\n")
+        registry.write("namespace redfish::privileges{\n")
+
+        privilege_dict = {}
+        for mapping in json_file["Mappings"]:
+            # first pass, identify all the unique privilege sets
+            for operation, privilege_list in mapping["OperationMap"].items():
+                privilege_dict[get_privilege_string_from_list(
+                    privilege_list)] = (privilege_list, )
+        registry.write("// clang-format off\n")
+        for index, key in enumerate(privilege_dict):
+            (privilege_list, ) = privilege_dict[key]
+            name = get_variable_name_for_privilege_set(privilege_list)
+            registry.write("const std::array<Privileges, {}> privilegeSet{} = {};\n".format(
+                len(privilege_list), name, key))
+            privilege_dict[key] = (privilege_list, name)
+        registry.write("// clang-format on\n\n")
+
+        for mapping in json_file["Mappings"]:
+            entity = mapping["Entity"]
+            registry.write("//{}\n".format(entity))
+            for operation, privilege_list in mapping["OperationMap"].items():
+                privilege_string = get_privilege_string_from_list(
+                    privilege_list)
+                operation = operation.lower()
+
+                registry.write("const auto& {}{} = privilegeSet{};\n".format(
+                   operation, entity , privilege_dict[privilege_string][1]))
+            registry.write("\n")
+        registry.write("} // namespace redfish::privileges\n")
+    clang_format(path)
+
+
+make_privilege_registry()