commit 4f48d5f67f293e50340e7f4bf866435e03a6fc62
author Ed Tanous <edtanous@google.com> Mon Jun 21 08:27:45 2021 -0700
committer Ed Tanous <ed@tanous.net> Tue Jul 13 18:54:54 2021 +0000
tree a18e9b9826fadb48721f700e2cfa749879ecce15
parent 83fd8e19867f43f3a175d1ede65ad8636da553b3

Make code compile with clang-13

Clang-13 rightfully warns that the hasWebuiRoute variable isn't declared
as static.  This commit resolves that, and adds the static keyword so it
can be used in multiple compile units.  It also adds the static keyword
to the privilege registry, and the inline keyword to many methods that
now need it.

clang-format is also updated to version 12 in parse_registies.py, as
that's what CI uses, and what most people have installed.

Tested:
Followed clang-tidy instructions in README.md
"bitbake bmcweb" step now succeeds.

Signed-off-by: Ed Tanous <edtanous@google.com>
Change-Id: Id43b13606754cb37a404799fce155599ac3a3240

include/forward_unauthorized.hpp

diff --git a/include/forward_unauthorized.hpp b/include/forward_unauthorized.hpp
index 02e1123..46a25d4 100644
--- a/include/forward_unauthorized.hpp
+++ b/include/forward_unauthorized.hpp
@@ -6,7 +6,7 @@
 namespace forward_unauthorized
 {
 
-bool hasWebuiRoute = false;
+static bool hasWebuiRoute = false;
 
 inline void sendUnauthorized(const crow::Request& req, crow::Response& res)
 {

redfish-core/include/registries/privilege_registry.hpp

diff --git a/redfish-core/include/registries/privilege_registry.hpp b/redfish-core/include/registries/privilege_registry.hpp
index 706a24c..e95a314 100644
--- a/redfish-core/include/registries/privilege_registry.hpp
+++ b/redfish-core/include/registries/privilege_registry.hpp
@@ -37,1306 +37,1406 @@
 // 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;
+const static auto& getAccelerationFunction = privilegeSetLogin;
+const static auto& headAccelerationFunction = privilegeSetLogin;
+const static auto& patchAccelerationFunction = privilegeSetConfigureComponents;
+const static auto& putAccelerationFunction = privilegeSetConfigureComponents;
+const static auto& deleteAccelerationFunction = privilegeSetConfigureComponents;
+const static auto& postAccelerationFunction = privilegeSetConfigureComponents;
 
 // AccelerationFunctionCollection
-const auto& getAccelerationFunctionCollection = privilegeSetLogin;
-const auto& headAccelerationFunctionCollection = privilegeSetLogin;
-const auto& patchAccelerationFunctionCollection =
+const static auto& getAccelerationFunctionCollection = privilegeSetLogin;
+const static auto& headAccelerationFunctionCollection = privilegeSetLogin;
+const static auto& patchAccelerationFunctionCollection =
     privilegeSetConfigureComponents;
-const auto& putAccelerationFunctionCollection = privilegeSetConfigureComponents;
-const auto& deleteAccelerationFunctionCollection =
+const static auto& putAccelerationFunctionCollection =
     privilegeSetConfigureComponents;
-const auto& postAccelerationFunctionCollection =
+const static auto& deleteAccelerationFunctionCollection =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getAccountService = privilegeSetLogin;
+const static auto& headAccountService = privilegeSetLogin;
+const static auto& patchAccountService = privilegeSetConfigureUsers;
+const static auto& putAccountService = privilegeSetConfigureUsers;
+const static auto& deleteAccountService = privilegeSetConfigureUsers;
+const static 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;
+const static auto& getActionInfo = privilegeSetLogin;
+const static auto& headActionInfo = privilegeSetLogin;
+const static auto& patchActionInfo = privilegeSetConfigureManager;
+const static auto& putActionInfo = privilegeSetConfigureManager;
+const static auto& deleteActionInfo = privilegeSetConfigureManager;
+const static 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;
+const static auto& getAddressPool = privilegeSetLogin;
+const static auto& headAddressPool = privilegeSetLogin;
+const static auto& patchAddressPool = privilegeSetConfigureComponents;
+const static auto& putAddressPool = privilegeSetConfigureComponents;
+const static auto& deleteAddressPool = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getAddressPoolCollection = privilegeSetLogin;
+const static auto& headAddressPoolCollection = privilegeSetLogin;
+const static auto& patchAddressPoolCollection = privilegeSetConfigureComponents;
+const static auto& putAddressPoolCollection = privilegeSetConfigureComponents;
+const static auto& deleteAddressPoolCollection =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getAggregate = privilegeSetLogin;
+const static auto& headAggregate = privilegeSetLogin;
+const static auto& patchAggregate =
+    privilegeSetConfigureManagerOrConfigureComponents;
+const static auto& putAggregate =
+    privilegeSetConfigureManagerOrConfigureComponents;
+const static auto& deleteAggregate =
+    privilegeSetConfigureManagerOrConfigureComponents;
+const static auto& postAggregate =
+    privilegeSetConfigureManagerOrConfigureComponents;
 
 // AggregateCollection
-const auto& getAggregateCollection = privilegeSetLogin;
-const auto& headAggregateCollection = privilegeSetLogin;
-const auto& patchAggregateCollection =
+const static auto& getAggregateCollection = privilegeSetLogin;
+const static auto& headAggregateCollection = privilegeSetLogin;
+const static auto& patchAggregateCollection =
     privilegeSetConfigureManagerOrConfigureComponents;
-const auto& putAggregateCollection =
+const static auto& putAggregateCollection =
     privilegeSetConfigureManagerOrConfigureComponents;
-const auto& deleteAggregateCollection =
+const static auto& deleteAggregateCollection =
     privilegeSetConfigureManagerOrConfigureComponents;
-const auto& postAggregateCollection =
+const static 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;
+const static auto& getAggregationService = privilegeSetLogin;
+const static auto& headAggregationService = privilegeSetLogin;
+const static auto& patchAggregationService = privilegeSetConfigureManager;
+const static auto& putAggregationService = privilegeSetConfigureManager;
+const static auto& deleteAggregationService = privilegeSetConfigureManager;
+const static 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;
+const static auto& getAggregationSource = privilegeSetLogin;
+const static auto& headAggregationSource = privilegeSetLogin;
+const static auto& patchAggregationSource = privilegeSetConfigureManager;
+const static auto& putAggregationSource = privilegeSetConfigureManager;
+const static auto& deleteAggregationSource = privilegeSetConfigureManager;
+const static 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;
+const static auto& getAggregationSourceCollection = privilegeSetLogin;
+const static auto& headAggregationSourceCollection = privilegeSetLogin;
+const static auto& patchAggregationSourceCollection =
+    privilegeSetConfigureManager;
+const static auto& putAggregationSourceCollection =
+    privilegeSetConfigureManager;
+const static auto& deleteAggregationSourceCollection =
+    privilegeSetConfigureManager;
+const static 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;
+const static auto& getAssembly = privilegeSetLogin;
+const static auto& headAssembly = privilegeSetLogin;
+const static auto& patchAssembly = privilegeSetConfigureComponents;
+const static auto& putAssembly = privilegeSetConfigureComponents;
+const static auto& deleteAssembly = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getBios = privilegeSetLogin;
+const static auto& headBios = privilegeSetLogin;
+const static auto& patchBios = privilegeSetConfigureComponents;
+const static auto& postBios = privilegeSetConfigureComponents;
+const static auto& putBios = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getBootOption = privilegeSetLogin;
+const static auto& headBootOption = privilegeSetLogin;
+const static auto& patchBootOption = privilegeSetConfigureComponents;
+const static auto& putBootOption = privilegeSetConfigureComponents;
+const static auto& deleteBootOption = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getBootOptionCollection = privilegeSetLogin;
+const static auto& headBootOptionCollection = privilegeSetLogin;
+const static auto& patchBootOptionCollection = privilegeSetConfigureComponents;
+const static auto& putBootOptionCollection = privilegeSetConfigureComponents;
+const static auto& deleteBootOptionCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getCertificate = privilegeSetConfigureManager;
+const static auto& headCertificate = privilegeSetConfigureManager;
+const static auto& patchCertificate = privilegeSetConfigureManager;
+const static auto& putCertificate = privilegeSetConfigureManager;
+const static auto& deleteCertificate = privilegeSetConfigureManager;
+const static 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;
+const static auto& getCertificateCollection = privilegeSetConfigureManager;
+const static auto& headCertificateCollection = privilegeSetConfigureManager;
+const static auto& patchCertificateCollection = privilegeSetConfigureManager;
+const static auto& putCertificateCollection = privilegeSetConfigureManager;
+const static auto& deleteCertificateCollection = privilegeSetConfigureManager;
+const static 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;
+const static auto& getCertificateLocations = privilegeSetConfigureManager;
+const static auto& headCertificateLocations = privilegeSetConfigureManager;
+const static auto& patchCertificateLocations = privilegeSetConfigureManager;
+const static auto& putCertificateLocations = privilegeSetConfigureManager;
+const static auto& deleteCertificateLocations = privilegeSetConfigureManager;
+const static 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;
+const static auto& getCertificateService = privilegeSetLogin;
+const static auto& headCertificateService = privilegeSetLogin;
+const static auto& patchCertificateService = privilegeSetConfigureManager;
+const static auto& putCertificateService = privilegeSetConfigureManager;
+const static auto& deleteCertificateService = privilegeSetConfigureManager;
+const static 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;
+const static auto& getChassis = privilegeSetLogin;
+const static auto& headChassis = privilegeSetLogin;
+const static auto& patchChassis = privilegeSetConfigureComponents;
+const static auto& putChassis = privilegeSetConfigureComponents;
+const static auto& deleteChassis = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getChassisCollection = privilegeSetLogin;
+const static auto& headChassisCollection = privilegeSetLogin;
+const static auto& patchChassisCollection = privilegeSetConfigureComponents;
+const static auto& putChassisCollection = privilegeSetConfigureComponents;
+const static auto& deleteChassisCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getCircuit = privilegeSetLogin;
+const static auto& headCircuit = privilegeSetLogin;
+const static auto& patchCircuit = privilegeSetConfigureComponents;
+const static auto& putCircuit = privilegeSetConfigureComponents;
+const static auto& deleteCircuit = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getCircuitCollection = privilegeSetLogin;
+const static auto& headCircuitCollection = privilegeSetLogin;
+const static auto& patchCircuitCollection = privilegeSetConfigureComponents;
+const static auto& putCircuitCollection = privilegeSetConfigureComponents;
+const static auto& deleteCircuitCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getCompositionService = privilegeSetLogin;
+const static auto& headCompositionService = privilegeSetLogin;
+const static auto& patchCompositionService = privilegeSetConfigureManager;
+const static auto& putCompositionService = privilegeSetConfigureManager;
+const static auto& deleteCompositionService = privilegeSetConfigureManager;
+const static 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;
+const static auto& getComputerSystem = privilegeSetLogin;
+const static auto& headComputerSystem = privilegeSetLogin;
+const static auto& patchComputerSystem = privilegeSetConfigureComponents;
+const static auto& postComputerSystem = privilegeSetConfigureComponents;
+const static auto& putComputerSystem = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getComputerSystemCollection = privilegeSetLogin;
+const static auto& headComputerSystemCollection = privilegeSetLogin;
+const static auto& patchComputerSystemCollection =
+    privilegeSetConfigureComponents;
+const static auto& postComputerSystemCollection =
+    privilegeSetConfigureComponents;
+const static auto& putComputerSystemCollection =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getConnection = privilegeSetLogin;
+const static auto& headConnection = privilegeSetLogin;
+const static auto& patchConnection = privilegeSetConfigureComponents;
+const static auto& postConnection = privilegeSetConfigureComponents;
+const static auto& putConnection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getConnectionCollection = privilegeSetLogin;
+const static auto& headConnectionCollection = privilegeSetLogin;
+const static auto& patchConnectionCollection = privilegeSetConfigureComponents;
+const static auto& postConnectionCollection = privilegeSetConfigureComponents;
+const static auto& putConnectionCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getConnectionMethod = privilegeSetLogin;
+const static auto& headConnectionMethod = privilegeSetLogin;
+const static auto& patchConnectionMethod = privilegeSetConfigureManager;
+const static auto& putConnectionMethod = privilegeSetConfigureManager;
+const static auto& deleteConnectionMethod = privilegeSetConfigureManager;
+const static 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;
+const static auto& getConnectionMethodCollection = privilegeSetLogin;
+const static auto& headConnectionMethodCollection = privilegeSetLogin;
+const static auto& patchConnectionMethodCollection =
+    privilegeSetConfigureManager;
+const static auto& putConnectionMethodCollection = privilegeSetConfigureManager;
+const static auto& deleteConnectionMethodCollection =
+    privilegeSetConfigureManager;
+const static 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;
+const static auto& getDrive = privilegeSetLogin;
+const static auto& headDrive = privilegeSetLogin;
+const static auto& patchDrive = privilegeSetConfigureComponents;
+const static auto& postDrive = privilegeSetConfigureComponents;
+const static auto& putDrive = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getDriveCollection = privilegeSetLogin;
+const static auto& headDriveCollection = privilegeSetLogin;
+const static auto& patchDriveCollection = privilegeSetConfigureComponents;
+const static auto& postDriveCollection = privilegeSetConfigureComponents;
+const static auto& putDriveCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getEndpoint = privilegeSetLogin;
+const static auto& headEndpoint = privilegeSetLogin;
+const static auto& patchEndpoint = privilegeSetConfigureComponents;
+const static auto& postEndpoint = privilegeSetConfigureComponents;
+const static auto& putEndpoint = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getEndpointCollection = privilegeSetLogin;
+const static auto& headEndpointCollection = privilegeSetLogin;
+const static auto& patchEndpointCollection = privilegeSetConfigureComponents;
+const static auto& postEndpointCollection = privilegeSetConfigureComponents;
+const static auto& putEndpointCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getEndpointGroup = privilegeSetLogin;
+const static auto& headEndpointGroup = privilegeSetLogin;
+const static auto& patchEndpointGroup = privilegeSetConfigureComponents;
+const static auto& postEndpointGroup = privilegeSetConfigureComponents;
+const static auto& putEndpointGroup = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getEndpointGroupCollection = privilegeSetLogin;
+const static auto& headEndpointGroupCollection = privilegeSetLogin;
+const static auto& patchEndpointGroupCollection =
+    privilegeSetConfigureComponents;
+const static auto& postEndpointGroupCollection =
+    privilegeSetConfigureComponents;
+const static auto& putEndpointGroupCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getEthernetInterface = privilegeSetLogin;
+const static auto& headEthernetInterface = privilegeSetLogin;
+const static auto& patchEthernetInterface = privilegeSetConfigureComponents;
+const static auto& postEthernetInterface = privilegeSetConfigureComponents;
+const static auto& putEthernetInterface = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getEthernetInterfaceCollection = privilegeSetLogin;
+const static auto& headEthernetInterfaceCollection = privilegeSetLogin;
+const static auto& patchEthernetInterfaceCollection =
+    privilegeSetConfigureComponents;
+const static auto& postEthernetInterfaceCollection =
+    privilegeSetConfigureComponents;
+const static auto& putEthernetInterfaceCollection =
+    privilegeSetConfigureComponents;
+const static 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 =
+const static auto& getEventDestination = privilegeSetLogin;
+const static auto& headEventDestination = privilegeSetLogin;
+const static auto& patchEventDestination =
+    privilegeSetConfigureManagerOrConfigureSelf;
+const static auto& postEventDestination =
+    privilegeSetConfigureManagerOrConfigureSelf;
+const static auto& putEventDestination =
+    privilegeSetConfigureManagerOrConfigureSelf;
+const static auto& deleteEventDestination =
     privilegeSetConfigureManagerOrConfigureSelf;
 
 // EventDestinationCollection
-const auto& getEventDestinationCollection = privilegeSetLogin;
-const auto& headEventDestinationCollection = privilegeSetLogin;
-const auto& patchEventDestinationCollection =
+const static auto& getEventDestinationCollection = privilegeSetLogin;
+const static auto& headEventDestinationCollection = privilegeSetLogin;
+const static auto& patchEventDestinationCollection =
     privilegeSetConfigureManagerOrConfigureComponents;
-const auto& postEventDestinationCollection =
+const static auto& postEventDestinationCollection =
     privilegeSetConfigureManagerOrConfigureComponents;
-const auto& putEventDestinationCollection =
+const static auto& putEventDestinationCollection =
     privilegeSetConfigureManagerOrConfigureComponents;
-const auto& deleteEventDestinationCollection =
+const static 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;
+const static auto& getEventService = privilegeSetLogin;
+const static auto& headEventService = privilegeSetLogin;
+const static auto& patchEventService = privilegeSetConfigureManager;
+const static auto& postEventService = privilegeSetConfigureManager;
+const static auto& putEventService = privilegeSetConfigureManager;
+const static 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;
+const static auto& getExternalAccountProvider = privilegeSetLogin;
+const static auto& headExternalAccountProvider = privilegeSetLogin;
+const static auto& patchExternalAccountProvider = privilegeSetConfigureManager;
+const static auto& putExternalAccountProvider = privilegeSetConfigureManager;
+const static auto& deleteExternalAccountProvider = privilegeSetConfigureManager;
+const static auto& postExternalAccountProvider = privilegeSetConfigureManager;
 
 // ExternalAccountProviderCollection
-const auto& getExternalAccountProviderCollection = privilegeSetLogin;
-const auto& headExternalAccountProviderCollection = privilegeSetLogin;
-const auto& patchExternalAccountProviderCollection =
+const static auto& getExternalAccountProviderCollection = privilegeSetLogin;
+const static auto& headExternalAccountProviderCollection = privilegeSetLogin;
+const static auto& patchExternalAccountProviderCollection =
     privilegeSetConfigureManager;
-const auto& putExternalAccountProviderCollection = privilegeSetConfigureManager;
-const auto& deleteExternalAccountProviderCollection =
+const static auto& putExternalAccountProviderCollection =
     privilegeSetConfigureManager;
-const auto& postExternalAccountProviderCollection =
+const static auto& deleteExternalAccountProviderCollection =
+    privilegeSetConfigureManager;
+const static 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;
+const static auto& getFabric = privilegeSetLogin;
+const static auto& headFabric = privilegeSetLogin;
+const static auto& patchFabric = privilegeSetConfigureComponents;
+const static auto& postFabric = privilegeSetConfigureComponents;
+const static auto& putFabric = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getFabricCollection = privilegeSetLogin;
+const static auto& headFabricCollection = privilegeSetLogin;
+const static auto& patchFabricCollection = privilegeSetConfigureComponents;
+const static auto& postFabricCollection = privilegeSetConfigureComponents;
+const static auto& putFabricCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getFabricAdapter = privilegeSetLogin;
+const static auto& headFabricAdapter = privilegeSetLogin;
+const static auto& patchFabricAdapter = privilegeSetConfigureComponents;
+const static auto& postFabricAdapter = privilegeSetConfigureComponents;
+const static auto& putFabricAdapter = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getFabricAdapterCollection = privilegeSetLogin;
+const static auto& headFabricAdapterCollection = privilegeSetLogin;
+const static auto& patchFabricAdapterCollection =
+    privilegeSetConfigureComponents;
+const static auto& postFabricAdapterCollection =
+    privilegeSetConfigureComponents;
+const static auto& putFabricAdapterCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getFacility = privilegeSetLogin;
+const static auto& headFacility = privilegeSetLogin;
+const static auto& patchFacility = privilegeSetConfigureComponents;
+const static auto& putFacility = privilegeSetConfigureComponents;
+const static auto& deleteFacility = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getFacilityCollection = privilegeSetLogin;
+const static auto& headFacilityCollection = privilegeSetLogin;
+const static auto& patchFacilityCollection = privilegeSetConfigureComponents;
+const static auto& putFacilityCollection = privilegeSetConfigureComponents;
+const static auto& deleteFacilityCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getHostInterface = privilegeSetLogin;
+const static auto& headHostInterface = privilegeSetLogin;
+const static auto& patchHostInterface = privilegeSetConfigureManager;
+const static auto& postHostInterface = privilegeSetConfigureManager;
+const static auto& putHostInterface = privilegeSetConfigureManager;
+const static 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;
+const static auto& getHostInterfaceCollection = privilegeSetLogin;
+const static auto& headHostInterfaceCollection = privilegeSetLogin;
+const static auto& patchHostInterfaceCollection = privilegeSetConfigureManager;
+const static auto& postHostInterfaceCollection = privilegeSetConfigureManager;
+const static auto& putHostInterfaceCollection = privilegeSetConfigureManager;
+const static 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;
+const static auto& getJob = privilegeSetLogin;
+const static auto& headJob = privilegeSetLogin;
+const static auto& patchJob = privilegeSetConfigureManager;
+const static auto& putJob = privilegeSetConfigureManager;
+const static auto& deleteJob = privilegeSetConfigureManager;
+const static 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;
+const static auto& getJobCollection = privilegeSetLogin;
+const static auto& headJobCollection = privilegeSetLogin;
+const static auto& patchJobCollection = privilegeSetConfigureManager;
+const static auto& putJobCollection = privilegeSetConfigureManager;
+const static auto& deleteJobCollection = privilegeSetConfigureManager;
+const static 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;
+const static auto& getJobService = privilegeSetLogin;
+const static auto& headJobService = privilegeSetLogin;
+const static auto& patchJobService = privilegeSetConfigureManager;
+const static auto& putJobService = privilegeSetConfigureManager;
+const static auto& deleteJobService = privilegeSetConfigureManager;
+const static 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;
+const static auto& getJsonSchemaFile = privilegeSetLogin;
+const static auto& headJsonSchemaFile = privilegeSetLogin;
+const static auto& patchJsonSchemaFile = privilegeSetConfigureManager;
+const static auto& postJsonSchemaFile = privilegeSetConfigureManager;
+const static auto& putJsonSchemaFile = privilegeSetConfigureManager;
+const static 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;
+const static auto& getJsonSchemaFileCollection = privilegeSetLogin;
+const static auto& headJsonSchemaFileCollection = privilegeSetLogin;
+const static auto& patchJsonSchemaFileCollection = privilegeSetConfigureManager;
+const static auto& postJsonSchemaFileCollection = privilegeSetConfigureManager;
+const static auto& putJsonSchemaFileCollection = privilegeSetConfigureManager;
+const static 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;
+const static auto& getLogEntry = privilegeSetLogin;
+const static auto& headLogEntry = privilegeSetLogin;
+const static auto& patchLogEntry = privilegeSetConfigureManager;
+const static auto& putLogEntry = privilegeSetConfigureManager;
+const static auto& deleteLogEntry = privilegeSetConfigureManager;
+const static 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;
+const static auto& getLogEntryCollection = privilegeSetLogin;
+const static auto& headLogEntryCollection = privilegeSetLogin;
+const static auto& patchLogEntryCollection = privilegeSetConfigureManager;
+const static auto& putLogEntryCollection = privilegeSetConfigureManager;
+const static auto& deleteLogEntryCollection = privilegeSetConfigureManager;
+const static 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;
+const static auto& getLogService = privilegeSetLogin;
+const static auto& headLogService = privilegeSetLogin;
+const static auto& patchLogService = privilegeSetConfigureManager;
+const static auto& putLogService = privilegeSetConfigureManager;
+const static auto& deleteLogService = privilegeSetConfigureManager;
+const static 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;
+const static auto& getLogServiceCollection = privilegeSetLogin;
+const static auto& headLogServiceCollection = privilegeSetLogin;
+const static auto& patchLogServiceCollection = privilegeSetConfigureManager;
+const static auto& putLogServiceCollection = privilegeSetConfigureManager;
+const static auto& deleteLogServiceCollection = privilegeSetConfigureManager;
+const static 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;
+const static auto& getManager = privilegeSetLogin;
+const static auto& headManager = privilegeSetLogin;
+const static auto& patchManager = privilegeSetConfigureManager;
+const static auto& postManager = privilegeSetConfigureManager;
+const static auto& putManager = privilegeSetConfigureManager;
+const static 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;
+const static auto& getManagerCollection = privilegeSetLogin;
+const static auto& headManagerCollection = privilegeSetLogin;
+const static auto& patchManagerCollection = privilegeSetConfigureManager;
+const static auto& postManagerCollection = privilegeSetConfigureManager;
+const static auto& putManagerCollection = privilegeSetConfigureManager;
+const static auto& deleteManagerCollection = privilegeSetConfigureManager;
 
 // ManagerAccount
-const auto& getManagerAccount =
+const static auto& getManagerAccount =
     privilegeSetConfigureManagerOrConfigureUsersOrConfigureSelf;
-const auto& headManagerAccount = privilegeSetLogin;
-const auto& patchManagerAccount = privilegeSetConfigureUsers;
-const auto& postManagerAccount = privilegeSetConfigureUsers;
-const auto& putManagerAccount = privilegeSetConfigureUsers;
-const auto& deleteManagerAccount = privilegeSetConfigureUsers;
+const static auto& headManagerAccount = privilegeSetLogin;
+const static auto& patchManagerAccount = privilegeSetConfigureUsers;
+const static auto& postManagerAccount = privilegeSetConfigureUsers;
+const static auto& putManagerAccount = privilegeSetConfigureUsers;
+const static 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;
+const static auto& getManagerAccountCollection = privilegeSetLogin;
+const static auto& headManagerAccountCollection = privilegeSetLogin;
+const static auto& patchManagerAccountCollection = privilegeSetConfigureUsers;
+const static auto& putManagerAccountCollection = privilegeSetConfigureUsers;
+const static auto& deleteManagerAccountCollection = privilegeSetConfigureUsers;
+const static 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;
+const static auto& getManagerNetworkProtocol = privilegeSetLogin;
+const static auto& headManagerNetworkProtocol = privilegeSetLogin;
+const static auto& patchManagerNetworkProtocol = privilegeSetConfigureManager;
+const static auto& postManagerNetworkProtocol = privilegeSetConfigureManager;
+const static auto& putManagerNetworkProtocol = privilegeSetConfigureManager;
+const static 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;
+const static auto& getMediaController = privilegeSetLogin;
+const static auto& headMediaController = privilegeSetLogin;
+const static auto& patchMediaController = privilegeSetConfigureComponents;
+const static auto& postMediaController = privilegeSetConfigureComponents;
+const static auto& putMediaController = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getMediaControllerCollection = privilegeSetLogin;
+const static auto& headMediaControllerCollection = privilegeSetLogin;
+const static auto& patchMediaControllerCollection =
+    privilegeSetConfigureComponents;
+const static auto& postMediaControllerCollection =
+    privilegeSetConfigureComponents;
+const static auto& putMediaControllerCollection =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getMemory = privilegeSetLogin;
+const static auto& headMemory = privilegeSetLogin;
+const static auto& patchMemory = privilegeSetConfigureComponents;
+const static auto& postMemory = privilegeSetConfigureComponents;
+const static auto& putMemory = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getMemoryCollection = privilegeSetLogin;
+const static auto& headMemoryCollection = privilegeSetLogin;
+const static auto& patchMemoryCollection = privilegeSetConfigureComponents;
+const static auto& postMemoryCollection = privilegeSetConfigureComponents;
+const static auto& putMemoryCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getMemoryChunks = privilegeSetLogin;
+const static auto& headMemoryChunks = privilegeSetLogin;
+const static auto& patchMemoryChunks = privilegeSetConfigureComponents;
+const static auto& postMemoryChunks = privilegeSetConfigureComponents;
+const static auto& putMemoryChunks = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getMemoryChunksCollection = privilegeSetLogin;
+const static auto& headMemoryChunksCollection = privilegeSetLogin;
+const static auto& patchMemoryChunksCollection =
+    privilegeSetConfigureComponents;
+const static auto& postMemoryChunksCollection = privilegeSetConfigureComponents;
+const static auto& putMemoryChunksCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getMemoryDomain = privilegeSetLogin;
+const static auto& headMemoryDomain = privilegeSetLogin;
+const static auto& patchMemoryDomain = privilegeSetConfigureComponents;
+const static auto& postMemoryDomain = privilegeSetConfigureComponents;
+const static auto& putMemoryDomain = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getMemoryDomainCollection = privilegeSetLogin;
+const static auto& headMemoryDomainCollection = privilegeSetLogin;
+const static auto& patchMemoryDomainCollection =
+    privilegeSetConfigureComponents;
+const static auto& postMemoryDomainCollection = privilegeSetConfigureComponents;
+const static auto& putMemoryDomainCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getMemoryMetrics = privilegeSetLogin;
+const static auto& headMemoryMetrics = privilegeSetLogin;
+const static auto& patchMemoryMetrics = privilegeSetConfigureComponents;
+const static auto& postMemoryMetrics = privilegeSetConfigureComponents;
+const static auto& putMemoryMetrics = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getMessageRegistryFile = privilegeSetLogin;
+const static auto& headMessageRegistryFile = privilegeSetLogin;
+const static auto& patchMessageRegistryFile = privilegeSetConfigureManager;
+const static auto& postMessageRegistryFile = privilegeSetConfigureManager;
+const static auto& putMessageRegistryFile = privilegeSetConfigureManager;
+const static 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;
+const static auto& getMessageRegistryFileCollection = privilegeSetLogin;
+const static auto& headMessageRegistryFileCollection = privilegeSetLogin;
+const static auto& patchMessageRegistryFileCollection =
+    privilegeSetConfigureManager;
+const static auto& postMessageRegistryFileCollection =
+    privilegeSetConfigureManager;
+const static auto& putMessageRegistryFileCollection =
+    privilegeSetConfigureManager;
+const static 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;
+const static auto& getMetricDefinition = privilegeSetLogin;
+const static auto& headMetricDefinition = privilegeSetLogin;
+const static auto& patchMetricDefinition = privilegeSetConfigureManager;
+const static auto& putMetricDefinition = privilegeSetConfigureManager;
+const static auto& deleteMetricDefinition = privilegeSetConfigureManager;
+const static 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;
+const static auto& getMetricDefinitionCollection = privilegeSetLogin;
+const static auto& headMetricDefinitionCollection = privilegeSetLogin;
+const static auto& patchMetricDefinitionCollection =
+    privilegeSetConfigureManager;
+const static auto& putMetricDefinitionCollection = privilegeSetConfigureManager;
+const static auto& deleteMetricDefinitionCollection =
+    privilegeSetConfigureManager;
+const static 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;
+const static auto& getMetricReport = privilegeSetLogin;
+const static auto& headMetricReport = privilegeSetLogin;
+const static auto& patchMetricReport = privilegeSetConfigureManager;
+const static auto& putMetricReport = privilegeSetConfigureManager;
+const static auto& deleteMetricReport = privilegeSetConfigureManager;
+const static 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;
+const static auto& getMetricReportCollection = privilegeSetLogin;
+const static auto& headMetricReportCollection = privilegeSetLogin;
+const static auto& patchMetricReportCollection = privilegeSetConfigureManager;
+const static auto& putMetricReportCollection = privilegeSetConfigureManager;
+const static auto& deleteMetricReportCollection = privilegeSetConfigureManager;
+const static 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;
+const static auto& getMetricReportDefinition = privilegeSetLogin;
+const static auto& headMetricReportDefinition = privilegeSetLogin;
+const static auto& patchMetricReportDefinition = privilegeSetConfigureManager;
+const static auto& putMetricReportDefinition = privilegeSetConfigureManager;
+const static auto& deleteMetricReportDefinition = privilegeSetConfigureManager;
+const static auto& postMetricReportDefinition = privilegeSetConfigureManager;
 
 // MetricReportDefinitionCollection
-const auto& getMetricReportDefinitionCollection = privilegeSetLogin;
-const auto& headMetricReportDefinitionCollection = privilegeSetLogin;
-const auto& patchMetricReportDefinitionCollection =
+const static auto& getMetricReportDefinitionCollection = privilegeSetLogin;
+const static auto& headMetricReportDefinitionCollection = privilegeSetLogin;
+const static auto& patchMetricReportDefinitionCollection =
     privilegeSetConfigureManager;
-const auto& putMetricReportDefinitionCollection = privilegeSetConfigureManager;
-const auto& deleteMetricReportDefinitionCollection =
+const static auto& putMetricReportDefinitionCollection =
     privilegeSetConfigureManager;
-const auto& postMetricReportDefinitionCollection = privilegeSetConfigureManager;
+const static auto& deleteMetricReportDefinitionCollection =
+    privilegeSetConfigureManager;
+const static 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;
+const static auto& getNetworkAdapter = privilegeSetLogin;
+const static auto& headNetworkAdapter = privilegeSetLogin;
+const static auto& patchNetworkAdapter = privilegeSetConfigureComponents;
+const static auto& postNetworkAdapter = privilegeSetConfigureComponents;
+const static auto& putNetworkAdapter = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getNetworkAdapterCollection = privilegeSetLogin;
+const static auto& headNetworkAdapterCollection = privilegeSetLogin;
+const static auto& patchNetworkAdapterCollection =
+    privilegeSetConfigureComponents;
+const static auto& postNetworkAdapterCollection =
+    privilegeSetConfigureComponents;
+const static auto& putNetworkAdapterCollection =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getNetworkDeviceFunction = privilegeSetLogin;
+const static auto& headNetworkDeviceFunction = privilegeSetLogin;
+const static auto& patchNetworkDeviceFunction = privilegeSetConfigureComponents;
+const static auto& postNetworkDeviceFunction = privilegeSetConfigureComponents;
+const static auto& putNetworkDeviceFunction = privilegeSetConfigureComponents;
+const static auto& deleteNetworkDeviceFunction =
+    privilegeSetConfigureComponents;
 
 // NetworkDeviceFunctionCollection
-const auto& getNetworkDeviceFunctionCollection = privilegeSetLogin;
-const auto& headNetworkDeviceFunctionCollection = privilegeSetLogin;
-const auto& patchNetworkDeviceFunctionCollection =
+const static auto& getNetworkDeviceFunctionCollection = privilegeSetLogin;
+const static auto& headNetworkDeviceFunctionCollection = privilegeSetLogin;
+const static auto& patchNetworkDeviceFunctionCollection =
     privilegeSetConfigureComponents;
-const auto& postNetworkDeviceFunctionCollection =
+const static auto& postNetworkDeviceFunctionCollection =
     privilegeSetConfigureComponents;
-const auto& putNetworkDeviceFunctionCollection =
+const static auto& putNetworkDeviceFunctionCollection =
     privilegeSetConfigureComponents;
-const auto& deleteNetworkDeviceFunctionCollection =
+const static 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;
+const static auto& getNetworkInterface = privilegeSetLogin;
+const static auto& headNetworkInterface = privilegeSetLogin;
+const static auto& patchNetworkInterface = privilegeSetConfigureComponents;
+const static auto& postNetworkInterface = privilegeSetConfigureComponents;
+const static auto& putNetworkInterface = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getNetworkInterfaceCollection = privilegeSetLogin;
+const static auto& headNetworkInterfaceCollection = privilegeSetLogin;
+const static auto& patchNetworkInterfaceCollection =
+    privilegeSetConfigureComponents;
+const static auto& postNetworkInterfaceCollection =
+    privilegeSetConfigureComponents;
+const static auto& putNetworkInterfaceCollection =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getNetworkPort = privilegeSetLogin;
+const static auto& headNetworkPort = privilegeSetLogin;
+const static auto& patchNetworkPort = privilegeSetConfigureComponents;
+const static auto& postNetworkPort = privilegeSetConfigureComponents;
+const static auto& putNetworkPort = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getNetworkPortCollection = privilegeSetLogin;
+const static auto& headNetworkPortCollection = privilegeSetLogin;
+const static auto& patchNetworkPortCollection = privilegeSetConfigureComponents;
+const static auto& postNetworkPortCollection = privilegeSetConfigureComponents;
+const static auto& putNetworkPortCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getOperatingConfig = privilegeSetLogin;
+const static auto& headOperatingConfig = privilegeSetLogin;
+const static auto& patchOperatingConfig = privilegeSetConfigureComponents;
+const static auto& postOperatingConfig = privilegeSetConfigureComponents;
+const static auto& putOperatingConfig = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getOperatingConfigCollection = privilegeSetLogin;
+const static auto& headOperatingConfigCollection = privilegeSetLogin;
+const static auto& patchOperatingConfigCollection =
+    privilegeSetConfigureComponents;
+const static auto& postOperatingConfigCollection =
+    privilegeSetConfigureComponents;
+const static auto& putOperatingConfigCollection =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getOutlet = privilegeSetLogin;
+const static auto& headOutlet = privilegeSetLogin;
+const static auto& patchOutlet = privilegeSetConfigureComponents;
+const static auto& postOutlet = privilegeSetConfigureComponents;
+const static auto& putOutlet = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getOutletCollection = privilegeSetLogin;
+const static auto& headOutletCollection = privilegeSetLogin;
+const static auto& patchOutletCollection = privilegeSetConfigureComponents;
+const static auto& postOutletCollection = privilegeSetConfigureComponents;
+const static auto& putOutletCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getOutletGroup = privilegeSetLogin;
+const static auto& headOutletGroup = privilegeSetLogin;
+const static auto& patchOutletGroup = privilegeSetConfigureComponents;
+const static auto& postOutletGroup = privilegeSetConfigureComponents;
+const static auto& putOutletGroup = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getOutletGroupCollection = privilegeSetLogin;
+const static auto& headOutletGroupCollection = privilegeSetLogin;
+const static auto& patchOutletGroupCollection = privilegeSetConfigureComponents;
+const static auto& postOutletGroupCollection = privilegeSetConfigureComponents;
+const static auto& putOutletGroupCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getPCIeDevice = privilegeSetLogin;
+const static auto& headPCIeDevice = privilegeSetLogin;
+const static auto& patchPCIeDevice = privilegeSetConfigureComponents;
+const static auto& postPCIeDevice = privilegeSetConfigureComponents;
+const static auto& putPCIeDevice = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getPCIeDeviceCollection = privilegeSetLogin;
+const static auto& headPCIeDeviceCollection = privilegeSetLogin;
+const static auto& patchPCIeDeviceCollection = privilegeSetConfigureComponents;
+const static auto& postPCIeDeviceCollection = privilegeSetConfigureComponents;
+const static auto& putPCIeDeviceCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getPCIeFunction = privilegeSetLogin;
+const static auto& headPCIeFunction = privilegeSetLogin;
+const static auto& patchPCIeFunction = privilegeSetConfigureComponents;
+const static auto& postPCIeFunction = privilegeSetConfigureComponents;
+const static auto& putPCIeFunction = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getPCIeFunctionCollection = privilegeSetLogin;
+const static auto& headPCIeFunctionCollection = privilegeSetLogin;
+const static auto& patchPCIeFunctionCollection =
+    privilegeSetConfigureComponents;
+const static auto& postPCIeFunctionCollection = privilegeSetConfigureComponents;
+const static auto& putPCIeFunctionCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getPCIeSlots = privilegeSetLogin;
+const static auto& headPCIeSlots = privilegeSetLogin;
+const static auto& patchPCIeSlots = privilegeSetConfigureComponents;
+const static auto& postPCIeSlots = privilegeSetConfigureComponents;
+const static auto& putPCIeSlots = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getPort = privilegeSetLogin;
+const static auto& headPort = privilegeSetLogin;
+const static auto& patchPort = privilegeSetConfigureComponents;
+const static auto& postPort = privilegeSetConfigureComponents;
+const static auto& putPort = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getPortCollection = privilegeSetLogin;
+const static auto& headPortCollection = privilegeSetLogin;
+const static auto& patchPortCollection = privilegeSetConfigureComponents;
+const static auto& postPortCollection = privilegeSetConfigureComponents;
+const static auto& putPortCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getPortMetrics = privilegeSetLogin;
+const static auto& headPortMetrics = privilegeSetLogin;
+const static auto& patchPortMetrics = privilegeSetConfigureComponents;
+const static auto& postPortMetrics = privilegeSetConfigureComponents;
+const static auto& putPortMetrics = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getPower = privilegeSetLogin;
+const static auto& headPower = privilegeSetLogin;
+const static auto& patchPower = privilegeSetConfigureManager;
+const static auto& putPower = privilegeSetConfigureManager;
+const static auto& deletePower = privilegeSetConfigureManager;
+const static 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;
+const static auto& getPowerDistribution = privilegeSetLogin;
+const static auto& headPowerDistribution = privilegeSetLogin;
+const static auto& patchPowerDistribution = privilegeSetConfigureComponents;
+const static auto& postPowerDistribution = privilegeSetConfigureComponents;
+const static auto& putPowerDistribution = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getPowerDistributionCollection = privilegeSetLogin;
+const static auto& headPowerDistributionCollection = privilegeSetLogin;
+const static auto& patchPowerDistributionCollection =
+    privilegeSetConfigureComponents;
+const static auto& postPowerDistributionCollection =
+    privilegeSetConfigureComponents;
+const static auto& putPowerDistributionCollection =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getPowerDistributionMetrics = privilegeSetLogin;
+const static auto& headPowerDistributionMetrics = privilegeSetLogin;
+const static auto& patchPowerDistributionMetrics =
+    privilegeSetConfigureComponents;
+const static auto& postPowerDistributionMetrics =
+    privilegeSetConfigureComponents;
+const static auto& putPowerDistributionMetrics =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getProcessor = privilegeSetLogin;
+const static auto& headProcessor = privilegeSetLogin;
+const static auto& patchProcessor = privilegeSetConfigureComponents;
+const static auto& putProcessor = privilegeSetConfigureComponents;
+const static auto& deleteProcessor = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getProcessorCollection = privilegeSetLogin;
+const static auto& headProcessorCollection = privilegeSetLogin;
+const static auto& patchProcessorCollection = privilegeSetConfigureComponents;
+const static auto& putProcessorCollection = privilegeSetConfigureComponents;
+const static auto& deleteProcessorCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getProcessorMetrics = privilegeSetLogin;
+const static auto& headProcessorMetrics = privilegeSetLogin;
+const static auto& patchProcessorMetrics = privilegeSetConfigureComponents;
+const static auto& putProcessorMetrics = privilegeSetConfigureComponents;
+const static auto& deleteProcessorMetrics = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getResourceBlock = privilegeSetLogin;
+const static auto& headResourceBlock = privilegeSetLogin;
+const static auto& patchResourceBlock = privilegeSetConfigureComponents;
+const static auto& putResourceBlock = privilegeSetConfigureComponents;
+const static auto& deleteResourceBlock = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getResourceBlockCollection = privilegeSetLogin;
+const static auto& headResourceBlockCollection = privilegeSetLogin;
+const static auto& patchResourceBlockCollection =
+    privilegeSetConfigureComponents;
+const static auto& putResourceBlockCollection = privilegeSetConfigureComponents;
+const static auto& deleteResourceBlockCollection =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getRole = privilegeSetLogin;
+const static auto& headRole = privilegeSetLogin;
+const static auto& patchRole = privilegeSetConfigureManager;
+const static auto& putRole = privilegeSetConfigureManager;
+const static auto& deleteRole = privilegeSetConfigureManager;
+const static 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;
+const static auto& getRoleCollection = privilegeSetLogin;
+const static auto& headRoleCollection = privilegeSetLogin;
+const static auto& patchRoleCollection = privilegeSetConfigureManager;
+const static auto& putRoleCollection = privilegeSetConfigureManager;
+const static auto& deleteRoleCollection = privilegeSetConfigureManager;
+const static 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;
+const static auto& getRouteEntry = privilegeSetLogin;
+const static auto& headRouteEntry = privilegeSetLogin;
+const static auto& patchRouteEntry = privilegeSetConfigureComponents;
+const static auto& putRouteEntry = privilegeSetConfigureComponents;
+const static auto& deleteRouteEntry = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getRouteEntryCollection = privilegeSetLogin;
+const static auto& headRouteEntryCollection = privilegeSetLogin;
+const static auto& patchRouteEntryCollection = privilegeSetConfigureComponents;
+const static auto& putRouteEntryCollection = privilegeSetConfigureComponents;
+const static auto& deleteRouteEntryCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getRouteEntrySet = privilegeSetLogin;
+const static auto& headRouteEntrySet = privilegeSetLogin;
+const static auto& patchRouteEntrySet = privilegeSetConfigureComponents;
+const static auto& putRouteEntrySet = privilegeSetConfigureComponents;
+const static auto& deleteRouteEntrySet = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getRouteEntrySetCollection = privilegeSetLogin;
+const static auto& headRouteEntrySetCollection = privilegeSetLogin;
+const static auto& patchRouteEntrySetCollection =
+    privilegeSetConfigureComponents;
+const static auto& putRouteEntrySetCollection = privilegeSetConfigureComponents;
+const static auto& deleteRouteEntrySetCollection =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getSecureBoot = privilegeSetLogin;
+const static auto& headSecureBoot = privilegeSetLogin;
+const static auto& patchSecureBoot = privilegeSetConfigureComponents;
+const static auto& postSecureBoot = privilegeSetConfigureComponents;
+const static auto& putSecureBoot = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getSecureBootDatabase = privilegeSetLogin;
+const static auto& headSecureBootDatabase = privilegeSetLogin;
+const static auto& patchSecureBootDatabase = privilegeSetConfigureComponents;
+const static auto& postSecureBootDatabase = privilegeSetConfigureComponents;
+const static auto& putSecureBootDatabase = privilegeSetConfigureComponents;
+const static 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 =
+const static auto& getSecureBootDatabaseCollection = privilegeSetLogin;
+const static auto& headSecureBootDatabaseCollection = privilegeSetLogin;
+const static auto& patchSecureBootDatabaseCollection =
+    privilegeSetConfigureComponents;
+const static auto& postSecureBootDatabaseCollection =
+    privilegeSetConfigureComponents;
+const static auto& putSecureBootDatabaseCollection =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getSensor = privilegeSetLogin;
+const static auto& headSensor = privilegeSetLogin;
+const static auto& patchSensor = privilegeSetConfigureComponents;
+const static auto& postSensor = privilegeSetConfigureComponents;
+const static auto& putSensor = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getSensorCollection = privilegeSetLogin;
+const static auto& headSensorCollection = privilegeSetLogin;
+const static auto& patchSensorCollection = privilegeSetConfigureComponents;
+const static auto& postSensorCollection = privilegeSetConfigureComponents;
+const static auto& putSensorCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getSerialInterface = privilegeSetLogin;
+const static auto& headSerialInterface = privilegeSetLogin;
+const static auto& patchSerialInterface = privilegeSetConfigureManager;
+const static auto& putSerialInterface = privilegeSetConfigureManager;
+const static auto& deleteSerialInterface = privilegeSetConfigureManager;
+const static 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;
+const static auto& getSerialInterfaceCollection = privilegeSetLogin;
+const static auto& headSerialInterfaceCollection = privilegeSetLogin;
+const static auto& patchSerialInterfaceCollection =
+    privilegeSetConfigureManager;
+const static auto& putSerialInterfaceCollection = privilegeSetConfigureManager;
+const static auto& deleteSerialInterfaceCollection =
+    privilegeSetConfigureManager;
+const static 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;
+const static auto& getServiceRoot = privilegeSetLoginOrNoAuth;
+const static auto& headServiceRoot = privilegeSetLoginOrNoAuth;
+const static auto& patchServiceRoot = privilegeSetConfigureManager;
+const static auto& putServiceRoot = privilegeSetConfigureManager;
+const static auto& deleteServiceRoot = privilegeSetConfigureManager;
+const static 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;
+const static auto& getSession = privilegeSetLogin;
+const static auto& headSession = privilegeSetLogin;
+const static auto& patchSession = privilegeSetConfigureManager;
+const static auto& putSession = privilegeSetConfigureManager;
+const static auto& deleteSession = privilegeSetConfigureManagerOrConfigureSelf;
+const static 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;
+const static auto& getSessionCollection = privilegeSetLogin;
+const static auto& headSessionCollection = privilegeSetLogin;
+const static auto& patchSessionCollection = privilegeSetConfigureManager;
+const static auto& putSessionCollection = privilegeSetConfigureManager;
+const static auto& deleteSessionCollection = privilegeSetConfigureManager;
+const static 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;
+const static auto& getSessionService = privilegeSetLogin;
+const static auto& headSessionService = privilegeSetLogin;
+const static auto& patchSessionService = privilegeSetConfigureManager;
+const static auto& putSessionService = privilegeSetConfigureManager;
+const static auto& deleteSessionService = privilegeSetConfigureManager;
+const static 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;
+const static auto& getSignature = privilegeSetLogin;
+const static auto& headSignature = privilegeSetLogin;
+const static auto& patchSignature = privilegeSetConfigureComponents;
+const static auto& postSignature = privilegeSetConfigureComponents;
+const static auto& putSignature = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getSignatureCollection = privilegeSetLogin;
+const static auto& headSignatureCollection = privilegeSetLogin;
+const static auto& patchSignatureCollection = privilegeSetConfigureComponents;
+const static auto& postSignatureCollection = privilegeSetConfigureComponents;
+const static auto& putSignatureCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getSimpleStorage = privilegeSetLogin;
+const static auto& headSimpleStorage = privilegeSetLogin;
+const static auto& patchSimpleStorage = privilegeSetConfigureComponents;
+const static auto& postSimpleStorage = privilegeSetConfigureComponents;
+const static auto& putSimpleStorage = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getSimpleStorageCollection = privilegeSetLogin;
+const static auto& headSimpleStorageCollection = privilegeSetLogin;
+const static auto& patchSimpleStorageCollection =
+    privilegeSetConfigureComponents;
+const static auto& postSimpleStorageCollection =
+    privilegeSetConfigureComponents;
+const static auto& putSimpleStorageCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getSoftwareInventory = privilegeSetLogin;
+const static auto& headSoftwareInventory = privilegeSetLogin;
+const static auto& patchSoftwareInventory = privilegeSetConfigureComponents;
+const static auto& postSoftwareInventory = privilegeSetConfigureComponents;
+const static auto& putSoftwareInventory = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getSoftwareInventoryCollection = privilegeSetLogin;
+const static auto& headSoftwareInventoryCollection = privilegeSetLogin;
+const static auto& patchSoftwareInventoryCollection =
+    privilegeSetConfigureComponents;
+const static auto& postSoftwareInventoryCollection =
+    privilegeSetConfigureComponents;
+const static auto& putSoftwareInventoryCollection =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getStorage = privilegeSetLogin;
+const static auto& headStorage = privilegeSetLogin;
+const static auto& patchStorage = privilegeSetConfigureComponents;
+const static auto& postStorage = privilegeSetConfigureComponents;
+const static auto& putStorage = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getStorageCollection = privilegeSetLogin;
+const static auto& headStorageCollection = privilegeSetLogin;
+const static auto& patchStorageCollection = privilegeSetConfigureComponents;
+const static auto& postStorageCollection = privilegeSetConfigureComponents;
+const static auto& putStorageCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getStorageController = privilegeSetLogin;
+const static auto& headStorageController = privilegeSetLogin;
+const static auto& patchStorageController = privilegeSetConfigureComponents;
+const static auto& postStorageController = privilegeSetConfigureComponents;
+const static auto& putStorageController = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getStorageControllerCollection = privilegeSetLogin;
+const static auto& headStorageControllerCollection = privilegeSetLogin;
+const static auto& patchStorageControllerCollection =
+    privilegeSetConfigureComponents;
+const static auto& postStorageControllerCollection =
+    privilegeSetConfigureComponents;
+const static auto& putStorageControllerCollection =
+    privilegeSetConfigureComponents;
+const static 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;
+const static auto& getSwitch = privilegeSetLogin;
+const static auto& headSwitch = privilegeSetLogin;
+const static auto& patchSwitch = privilegeSetConfigureComponents;
+const static auto& postSwitch = privilegeSetConfigureComponents;
+const static auto& putSwitch = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getSwitchCollection = privilegeSetLogin;
+const static auto& headSwitchCollection = privilegeSetLogin;
+const static auto& patchSwitchCollection = privilegeSetConfigureComponents;
+const static auto& postSwitchCollection = privilegeSetConfigureComponents;
+const static auto& putSwitchCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getTask = privilegeSetLogin;
+const static auto& headTask = privilegeSetLogin;
+const static auto& patchTask = privilegeSetConfigureManager;
+const static auto& putTask = privilegeSetConfigureManager;
+const static auto& deleteTask = privilegeSetConfigureManager;
+const static 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;
+const static auto& getTaskCollection = privilegeSetLogin;
+const static auto& headTaskCollection = privilegeSetLogin;
+const static auto& patchTaskCollection = privilegeSetConfigureManager;
+const static auto& putTaskCollection = privilegeSetConfigureManager;
+const static auto& deleteTaskCollection = privilegeSetConfigureManager;
+const static 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;
+const static auto& getTaskService = privilegeSetLogin;
+const static auto& headTaskService = privilegeSetLogin;
+const static auto& patchTaskService = privilegeSetConfigureManager;
+const static auto& putTaskService = privilegeSetConfigureManager;
+const static auto& deleteTaskService = privilegeSetConfigureManager;
+const static 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;
+const static auto& getTelemetryService = privilegeSetLogin;
+const static auto& headTelemetryService = privilegeSetLogin;
+const static auto& patchTelemetryService = privilegeSetConfigureManager;
+const static auto& putTelemetryService = privilegeSetConfigureManager;
+const static auto& deleteTelemetryService = privilegeSetConfigureManager;
+const static 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;
+const static auto& getThermal = privilegeSetLogin;
+const static auto& headThermal = privilegeSetLogin;
+const static auto& patchThermal = privilegeSetConfigureManager;
+const static auto& putThermal = privilegeSetConfigureManager;
+const static auto& deleteThermal = privilegeSetConfigureManager;
+const static 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;
+const static auto& getTriggers = privilegeSetLogin;
+const static auto& headTriggers = privilegeSetLogin;
+const static auto& patchTriggers = privilegeSetConfigureManager;
+const static auto& putTriggers = privilegeSetConfigureManager;
+const static auto& deleteTriggers = privilegeSetConfigureManager;
+const static 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;
+const static auto& getTriggersCollection = privilegeSetLogin;
+const static auto& headTriggersCollection = privilegeSetLogin;
+const static auto& patchTriggersCollection = privilegeSetConfigureManager;
+const static auto& putTriggersCollection = privilegeSetConfigureManager;
+const static auto& deleteTriggersCollection = privilegeSetConfigureManager;
+const static 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;
+const static auto& getUpdateService = privilegeSetLogin;
+const static auto& headUpdateService = privilegeSetLogin;
+const static auto& patchUpdateService = privilegeSetConfigureComponents;
+const static auto& postUpdateService = privilegeSetConfigureComponents;
+const static auto& putUpdateService = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getVCATEntry = privilegeSetLogin;
+const static auto& headVCATEntry = privilegeSetLogin;
+const static auto& patchVCATEntry = privilegeSetConfigureComponents;
+const static auto& putVCATEntry = privilegeSetConfigureComponents;
+const static auto& deleteVCATEntry = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getVCATEntryCollection = privilegeSetLogin;
+const static auto& headVCATEntryCollection = privilegeSetLogin;
+const static auto& patchVCATEntryCollection = privilegeSetConfigureComponents;
+const static auto& putVCATEntryCollection = privilegeSetConfigureComponents;
+const static auto& deleteVCATEntryCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getVLanNetworkInterface = privilegeSetLogin;
+const static auto& headVLanNetworkInterface = privilegeSetLogin;
+const static auto& patchVLanNetworkInterface = privilegeSetConfigureManager;
+const static auto& putVLanNetworkInterface = privilegeSetConfigureManager;
+const static auto& deleteVLanNetworkInterface = privilegeSetConfigureManager;
+const static 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;
+const static auto& getVLanNetworkInterfaceCollection = privilegeSetLogin;
+const static auto& headVLanNetworkInterfaceCollection = privilegeSetLogin;
+const static auto& patchVLanNetworkInterfaceCollection =
+    privilegeSetConfigureManager;
+const static auto& putVLanNetworkInterfaceCollection =
+    privilegeSetConfigureManager;
+const static auto& deleteVLanNetworkInterfaceCollection =
+    privilegeSetConfigureManager;
+const static 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;
+const static auto& getVirtualMedia = privilegeSetLogin;
+const static auto& headVirtualMedia = privilegeSetLogin;
+const static auto& patchVirtualMedia = privilegeSetConfigureManager;
+const static auto& putVirtualMedia = privilegeSetConfigureManager;
+const static auto& deleteVirtualMedia = privilegeSetConfigureManager;
+const static 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;
+const static auto& getVirtualMediaCollection = privilegeSetLogin;
+const static auto& headVirtualMediaCollection = privilegeSetLogin;
+const static auto& patchVirtualMediaCollection = privilegeSetConfigureManager;
+const static auto& putVirtualMediaCollection = privilegeSetConfigureManager;
+const static auto& deleteVirtualMediaCollection = privilegeSetConfigureManager;
+const static 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;
+const static auto& getVolume = privilegeSetLogin;
+const static auto& headVolume = privilegeSetLogin;
+const static auto& patchVolume = privilegeSetConfigureComponents;
+const static auto& postVolume = privilegeSetConfigureComponents;
+const static auto& putVolume = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getVolumeCollection = privilegeSetLogin;
+const static auto& headVolumeCollection = privilegeSetLogin;
+const static auto& patchVolumeCollection = privilegeSetConfigureComponents;
+const static auto& postVolumeCollection = privilegeSetConfigureComponents;
+const static auto& putVolumeCollection = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getZone = privilegeSetLogin;
+const static auto& headZone = privilegeSetLogin;
+const static auto& patchZone = privilegeSetConfigureComponents;
+const static auto& postZone = privilegeSetConfigureComponents;
+const static auto& putZone = privilegeSetConfigureComponents;
+const static 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;
+const static auto& getZoneCollection = privilegeSetLogin;
+const static auto& headZoneCollection = privilegeSetLogin;
+const static auto& patchZoneCollection = privilegeSetConfigureComponents;
+const static auto& postZoneCollection = privilegeSetConfigureComponents;
+const static auto& putZoneCollection = privilegeSetConfigureComponents;
+const static auto& deleteZoneCollection = privilegeSetConfigureComponents;
 
 } // namespace redfish::privileges

redfish-core/include/utils/time_utils.hpp

diff --git a/redfish-core/include/utils/time_utils.hpp b/redfish-core/include/utils/time_utils.hpp
index 9965d4d..ee21fd7 100644
--- a/redfish-core/include/utils/time_utils.hpp
+++ b/redfish-core/include/utils/time_utils.hpp
@@ -92,7 +92,7 @@
  * @brief Convert string that represents value in Duration Format to its numeric
  *        equivalent.
  */
-std::optional<std::chrono::milliseconds>
+inline std::optional<std::chrono::milliseconds>
     fromDurationString(const std::string& str)
 {
     std::chrono::milliseconds out = std::chrono::milliseconds::zero();

redfish-core/lib/account_service.hpp

diff --git a/redfish-core/lib/account_service.hpp b/redfish-core/lib/account_service.hpp
index bce1853..31bdd16 100644
--- a/redfish-core/lib/account_service.hpp
+++ b/redfish-core/lib/account_service.hpp
@@ -565,7 +565,7 @@
  * @param userName  userName to be filled from the given JSON.
  * @param password  password to be filled from the given JSON.
  */
-void parseLDAPAuthenticationJson(
+inline void parseLDAPAuthenticationJson(
     nlohmann::json input, const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
     std::optional<std::string>& username, std::optional<std::string>& password)
 {
@@ -597,11 +597,12 @@
  * @param groupaAttribute  password to be filled from the given JSON.
  */
 
-void parseLDAPServiceJson(nlohmann::json input,
-                          const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
-                          std::optional<std::vector<std::string>>& baseDNList,
-                          std::optional<std::string>& userNameAttribute,
-                          std::optional<std::string>& groupsAttribute)
+inline void
+    parseLDAPServiceJson(nlohmann::json input,
+                         const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+                         std::optional<std::vector<std::string>>& baseDNList,
+                         std::optional<std::string>& userNameAttribute,
+                         std::optional<std::string>& groupsAttribute)
 {
     std::optional<nlohmann::json> searchSettings;
 
@@ -631,7 +632,7 @@
  server(openLDAP/ActiveDirectory)
  */
 
-void handleServiceAddressPatch(
+inline void handleServiceAddressPatch(
     const std::vector<std::string>& serviceAddressList,
     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
     const std::string& ldapServerElementName,
@@ -673,10 +674,11 @@
  server(openLDAP/ActiveDirectory)
  */
 
-void handleUserNamePatch(const std::string& username,
-                         const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
-                         const std::string& ldapServerElementName,
-                         const std::string& ldapConfigObject)
+inline void
+    handleUserNamePatch(const std::string& username,
+                        const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+                        const std::string& ldapServerElementName,
+                        const std::string& ldapConfigObject)
 {
     crow::connections::systemBus->async_method_call(
         [asyncResp, username,
@@ -703,10 +705,11 @@
  *        server(openLDAP/ActiveDirectory)
  */
 
-void handlePasswordPatch(const std::string& password,
-                         const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
-                         const std::string& ldapServerElementName,
-                         const std::string& ldapConfigObject)
+inline void
+    handlePasswordPatch(const std::string& password,
+                        const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+                        const std::string& ldapServerElementName,
+                        const std::string& ldapConfigObject)
 {
     crow::connections::systemBus->async_method_call(
         [asyncResp, password,
@@ -735,10 +738,11 @@
  server(openLDAP/ActiveDirectory)
  */
 
-void handleBaseDNPatch(const std::vector<std::string>& baseDNList,
-                       const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
-                       const std::string& ldapServerElementName,
-                       const std::string& ldapConfigObject)
+inline void
+    handleBaseDNPatch(const std::vector<std::string>& baseDNList,
+                      const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+                      const std::string& ldapServerElementName,
+                      const std::string& ldapConfigObject)
 {
     crow::connections::systemBus->async_method_call(
         [asyncResp, baseDNList,
@@ -776,11 +780,11 @@
  server(openLDAP/ActiveDirectory)
  */
 
-void handleUserNameAttrPatch(
-    const std::string& userNameAttribute,
-    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
-    const std::string& ldapServerElementName,
-    const std::string& ldapConfigObject)
+inline void
+    handleUserNameAttrPatch(const std::string& userNameAttribute,
+                            const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+                            const std::string& ldapServerElementName,
+                            const std::string& ldapConfigObject)
 {
     crow::connections::systemBus->async_method_call(
         [asyncResp, userNameAttribute,
@@ -812,7 +816,7 @@
  server(openLDAP/ActiveDirectory)
  */
 
-void handleGroupNameAttrPatch(
+inline void handleGroupNameAttrPatch(
     const std::string& groupsAttribute,
     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
     const std::string& ldapServerElementName,
@@ -848,7 +852,7 @@
  server(openLDAP/ActiveDirectory)
  */
 
-void handleServiceEnablePatch(
+inline void handleServiceEnablePatch(
     bool serviceEnabled, const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
     const std::string& ldapServerElementName,
     const std::string& ldapConfigObject)
@@ -871,8 +875,9 @@
         ldapEnableInterface, "Enabled", std::variant<bool>(serviceEnabled));
 }
 
-void handleAuthMethodsPatch(nlohmann::json& input,
-                            const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+inline void
+    handleAuthMethodsPatch(nlohmann::json& input,
+                           const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
     std::optional<bool> basicAuth;
     std::optional<bool> cookie;
@@ -1404,11 +1409,11 @@
 
                         bool userCanSeeAllAccounts =
                             effectiveUserPrivileges.isSupersetOf(
-                                {{"ConfigureUsers"}});
+                                {"ConfigureUsers"});
 
                         bool userCanSeeSelf =
                             effectiveUserPrivileges.isSupersetOf(
-                                {{"ConfigureSelf"}});
+                                {"ConfigureSelf"});
 
                         nlohmann::json& memberArray =
                             asyncResp->res.jsonValue["Members"];
@@ -1580,7 +1585,7 @@
                 Privileges effectiveUserPrivileges =
                     redfish::getUserPrivileges(req.userRole);
                 Privileges requiredPermissionsToChangeNonSelf = {
-                    {"ConfigureUsers"}, {"ConfigureManager"}};
+                    "ConfigureUsers", "ConfigureManager"};
                 if (!effectiveUserPrivileges.isSupersetOf(
                         requiredPermissionsToChangeNonSelf))
                 {
@@ -1754,7 +1759,7 @@
                 if ((username != req.session->username))
                 {
                     Privileges requiredPermissionsToChangeNonSelf = {
-                        {"ConfigureUsers"}};
+                        "ConfigureUsers"};
                     Privileges effectiveUserPrivileges =
                         redfish::getUserPrivileges(req.userRole);
 

redfish-core/lib/certificate_service.hpp

diff --git a/redfish-core/lib/certificate_service.hpp b/redfish-core/lib/certificate_service.hpp
index 467b0fd..f26909b 100644
--- a/redfish-core/lib/certificate_service.hpp
+++ b/redfish-core/lib/certificate_service.hpp
@@ -941,10 +941,10 @@
  * @param[in] path  Path of the D-Bus service object
  * @return None
  */
-void getCertificateLocations(
-    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
-    const std::string& certURL, const std::string& path,
-    const std::string& service)
+inline void
+    getCertificateLocations(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+                            const std::string& certURL, const std::string& path,
+                            const std::string& service)
 {
     BMCWEB_LOG_DEBUG << "getCertificateLocations URI=" << certURL
                      << " Path=" << path << " service= " << service;

redfish-core/lib/ethernet.hpp

diff --git a/redfish-core/lib/ethernet.hpp b/redfish-core/lib/ethernet.hpp
index 5141300..82d44ae 100644
--- a/redfish-core/lib/ethernet.hpp
+++ b/redfish-core/lib/ethernet.hpp
@@ -1024,8 +1024,9 @@
         "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
 }
 
-void handleHostnamePatch(const std::string& hostname,
-                         const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+inline void
+    handleHostnamePatch(const std::string& hostname,
+                        const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
     // SHOULD handle host names of up to 255 characters(RFC 1123)
     if (hostname.length() > 255)
@@ -1047,9 +1048,10 @@
         std::variant<std::string>(hostname));
 }
 
-void handleDomainnamePatch(const std::string& ifaceId,
-                           const std::string& domainname,
-                           const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+inline void
+    handleDomainnamePatch(const std::string& ifaceId,
+                          const std::string& domainname,
+                          const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
     std::vector<std::string> vectorDomainname = {domainname};
     crow::connections::systemBus->async_method_call(
@@ -1066,7 +1068,7 @@
         std::variant<std::vector<std::string>>(vectorDomainname));
 }
 
-bool isHostnameValid(const std::string& hostname)
+inline bool isHostnameValid(const std::string& hostname)
 {
     // A valid host name can never have the dotted-decimal form (RFC 1123)
     if (std::all_of(hostname.begin(), hostname.end(), ::isdigit))
@@ -1083,7 +1085,7 @@
     return std::regex_match(hostname, pattern);
 }
 
-bool isDomainnameValid(const std::string& domainname)
+inline bool isDomainnameValid(const std::string& domainname)
 {
     // Can have multiple subdomains
     // Top Level Domain's min length is 2 character
@@ -1093,8 +1095,8 @@
     return std::regex_match(domainname, pattern);
 }
 
-void handleFqdnPatch(const std::string& ifaceId, const std::string& fqdn,
-                     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+inline void handleFqdnPatch(const std::string& ifaceId, const std::string& fqdn,
+                            const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
     // Total length of FQDN must not exceed 255 characters(RFC 1035)
     if (fqdn.length() > 255)
@@ -1125,9 +1127,10 @@
     handleDomainnamePatch(ifaceId, domainname, asyncResp);
 }
 
-void handleMACAddressPatch(const std::string& ifaceId,
-                           const std::string& macAddress,
-                           const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+inline void
+    handleMACAddressPatch(const std::string& ifaceId,
+                          const std::string& macAddress,
+                          const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
     crow::connections::systemBus->async_method_call(
         [asyncResp, macAddress](const boost::system::error_code ec) {
@@ -1144,9 +1147,10 @@
         std::variant<std::string>(macAddress));
 }
 
-void setDHCPEnabled(const std::string& ifaceId, const std::string& propertyName,
-                    const bool v4Value, const bool v6Value,
-                    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+inline void setDHCPEnabled(const std::string& ifaceId,
+                           const std::string& propertyName, const bool v4Value,
+                           const bool v6Value,
+                           const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
     const std::string dhcp = getDhcpEnabledEnumeration(v4Value, v6Value);
     crow::connections::systemBus->async_method_call(
@@ -1166,7 +1170,7 @@
         std::variant<std::string>{dhcp});
 }
 
-void setEthernetInterfaceBoolProperty(
+inline void setEthernetInterfaceBoolProperty(
     const std::string& ifaceId, const std::string& propertyName,
     const bool& value, const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
@@ -1186,8 +1190,8 @@
         std::variant<bool>{value});
 }
 
-void setDHCPv4Config(const std::string& propertyName, const bool& value,
-                     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+inline void setDHCPv4Config(const std::string& propertyName, const bool& value,
+                            const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
     BMCWEB_LOG_DEBUG << propertyName << " = " << value;
     crow::connections::systemBus->async_method_call(
@@ -1206,11 +1210,11 @@
         std::variant<bool>{value});
 }
 
-void handleDHCPPatch(const std::string& ifaceId,
-                     const EthernetInterfaceData& ethData,
-                     const DHCPParameters& v4dhcpParms,
-                     const DHCPParameters& v6dhcpParms,
-                     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+inline void handleDHCPPatch(const std::string& ifaceId,
+                            const EthernetInterfaceData& ethData,
+                            const DHCPParameters& v4dhcpParms,
+                            const DHCPParameters& v6dhcpParms,
+                            const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
     bool ipv4Active = translateDHCPEnabledToBool(ethData.DHCPEnabled, true);
     bool ipv6Active = translateDHCPEnabledToBool(ethData.DHCPEnabled, false);
@@ -1317,7 +1321,7 @@
     setDHCPv4Config("HostNameEnabled", nextUseDomain, asyncResp);
 }
 
-boost::container::flat_set<IPv4AddressData>::const_iterator
+inline boost::container::flat_set<IPv4AddressData>::const_iterator
     getNextStaticIpEntry(
         const boost::container::flat_set<IPv4AddressData>::const_iterator& head,
         const boost::container::flat_set<IPv4AddressData>::const_iterator& end)
@@ -1327,7 +1331,7 @@
     });
 }
 
-boost::container::flat_set<IPv6AddressData>::const_iterator
+inline boost::container::flat_set<IPv6AddressData>::const_iterator
     getNextStaticIpEntry(
         const boost::container::flat_set<IPv6AddressData>::const_iterator& head,
         const boost::container::flat_set<IPv6AddressData>::const_iterator& end)
@@ -1337,7 +1341,7 @@
     });
 }
 
-void handleIPv4StaticPatch(
+inline void handleIPv4StaticPatch(
     const std::string& ifaceId, nlohmann::json& input,
     const boost::container::flat_set<IPv4AddressData>& ipv4Data,
     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
@@ -1519,7 +1523,7 @@
     }
 }
 
-void handleStaticNameServersPatch(
+inline void handleStaticNameServersPatch(
     const std::string& ifaceId,
     const std::vector<std::string>& updatedStaticNameServers,
     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
@@ -1539,7 +1543,7 @@
         std::variant<std::vector<std::string>>{updatedStaticNameServers});
 }
 
-void handleIPv6StaticAddressesPatch(
+inline void handleIPv6StaticAddressesPatch(
     const std::string& ifaceId, const nlohmann::json& input,
     const boost::container::flat_set<IPv6AddressData>& ipv6Data,
     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
@@ -1660,7 +1664,7 @@
     }
 }
 
-void parseInterfaceData(
+inline void parseInterfaceData(
     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
     const std::string& ifaceId, const EthernetInterfaceData& ethData,
     const boost::container::flat_set<IPv4AddressData>& ipv4Data,
@@ -1801,10 +1805,10 @@
     }
 }
 
-void parseInterfaceData(nlohmann::json& jsonResponse,
-                        const std::string& parentIfaceId,
-                        const std::string& ifaceId,
-                        const EthernetInterfaceData& ethData)
+inline void parseInterfaceData(nlohmann::json& jsonResponse,
+                               const std::string& parentIfaceId,
+                               const std::string& ifaceId,
+                               const EthernetInterfaceData& ethData)
 {
     // Fill out obvious data...
     jsonResponse["Id"] = ifaceId;
@@ -1818,7 +1822,7 @@
     }
 }
 
-bool verifyNames(const std::string& parent, const std::string& iface)
+inline bool verifyNames(const std::string& parent, const std::string& iface)
 {
     if (!boost::starts_with(iface, parent + "_"))
     {

redfish-core/lib/log_services.hpp

diff --git a/redfish-core/lib/log_services.hpp b/redfish-core/lib/log_services.hpp
index b5fb066..a8f8955 100644
--- a/redfish-core/lib/log_services.hpp
+++ b/redfish-core/lib/log_services.hpp
@@ -1625,8 +1625,7 @@
                 BMCWEB_LOG_DEBUG << "Set Resolved";
 
                 crow::connections::systemBus->async_method_call(
-                    [asyncResp, resolved,
-                     entryId](const boost::system::error_code ec) {
+                    [asyncResp, entryId](const boost::system::error_code ec) {
                         if (ec)
                         {
                             BMCWEB_LOG_DEBUG << "DBUS response error " << ec;

redfish-core/lib/network_protocol.hpp

diff --git a/redfish-core/lib/network_protocol.hpp b/redfish-core/lib/network_protocol.hpp
index b74513b..6c28b9e 100644
--- a/redfish-core/lib/network_protocol.hpp
+++ b/redfish-core/lib/network_protocol.hpp
@@ -129,8 +129,8 @@
         "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
 }
 
-void getNetworkData(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
-                    const crow::Request& req)
+inline void getNetworkData(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+                           const crow::Request& req)
 {
     asyncResp->res.jsonValue["@odata.type"] =
         "#ManagerNetworkProtocol.v1_5_0.ManagerNetworkProtocol";
@@ -301,8 +301,9 @@
 }
 
 #ifdef BMCWEB_ALLOW_DEPRECATED_HOSTNAME_PATCH
-void handleHostnamePatch(const std::string& hostName,
-                         const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+inline void
+    handleHostnamePatch(const std::string& hostName,
+                        const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
     crow::connections::systemBus->async_method_call(
         [asyncResp](const boost::system::error_code ec) {
@@ -319,7 +320,7 @@
 }
 #endif
 
-void handleNTPProtocolEnabled(
+inline void handleNTPProtocolEnabled(
     const bool& ntpEnabled, const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
     std::string timeSyncMethod;
@@ -346,8 +347,9 @@
         std::variant<std::string>{timeSyncMethod});
 }
 
-void handleNTPServersPatch(const std::vector<std::string>& ntpServers,
-                           const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+inline void
+    handleNTPServersPatch(const std::vector<std::string>& ntpServers,
+                          const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
     crow::connections::systemBus->async_method_call(
         [asyncResp](const boost::system::error_code ec) {
@@ -363,9 +365,10 @@
         std::variant<std::vector<std::string>>{ntpServers});
 }
 
-void handleProtocolEnabled(const bool protocolEnabled,
-                           const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
-                           const std::string_view netBasePath)
+inline void
+    handleProtocolEnabled(const bool protocolEnabled,
+                          const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+                          const std::string_view netBasePath)
 {
     crow::connections::systemBus->async_method_call(
         [protocolEnabled, asyncResp,
@@ -417,7 +420,7 @@
             "xyz.openbmc_project.Control.Service.Attributes"});
 }
 
-std::string getHostName()
+inline std::string getHostName()
 {
     std::string hostName;
 
@@ -429,7 +432,8 @@
     return hostName;
 }
 
-void getNTPProtocolEnabled(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+inline void
+    getNTPProtocolEnabled(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
     crow::connections::systemBus->async_method_call(
         [asyncResp](const boost::system::error_code errorCode,

redfish-core/lib/power.hpp

diff --git a/redfish-core/lib/power.hpp b/redfish-core/lib/power.hpp
index 3a024d3..bf33250 100644
--- a/redfish-core/lib/power.hpp
+++ b/redfish-core/lib/power.hpp
@@ -23,7 +23,7 @@
 
 namespace redfish
 {
-void setPowerCapOverride(
+inline void setPowerCapOverride(
     const std::shared_ptr<SensorsAsyncResp>& sensorsAsyncResp,
     std::vector<nlohmann::json>& powerControlCollections)
 {

redfish-core/lib/redfish_sessions.hpp

diff --git a/redfish-core/lib/redfish_sessions.hpp b/redfish-core/lib/redfish_sessions.hpp
index 472151a..929e0c8 100644
--- a/redfish-core/lib/redfish_sessions.hpp
+++ b/redfish-core/lib/redfish_sessions.hpp
@@ -26,8 +26,8 @@
 
 class SessionCollection;
 
-void fillSessionObject(crow::Response& res,
-                       const persistent_data::UserSession& session)
+inline void fillSessionObject(crow::Response& res,
+                              const persistent_data::UserSession& session)
 {
     res.jsonValue["Id"] = session.uniqueId;
     res.jsonValue["UserName"] = session.username;
@@ -93,7 +93,7 @@
                         redfish::getUserPrivileges(req.userRole);
 
                     if (!effectiveUserPrivileges.isSupersetOf(
-                            {{"ConfigureUsers"}}))
+                            {"ConfigureUsers"}))
                     {
                         messages::insufficientPrivilege(asyncResp->res);
                         return;

redfish-core/lib/systems.hpp

diff --git a/redfish-core/lib/systems.hpp b/redfish-core/lib/systems.hpp
index 2b9636f..45a3249 100644
--- a/redfish-core/lib/systems.hpp
+++ b/redfish-core/lib/systems.hpp
@@ -2223,7 +2223,7 @@
     BMCWEB_ROUTE(app, "/redfish/v1/Systems/")
         .privileges(redfish::privileges::getComputerSystemCollection)
         .methods(boost::beast::http::verb::get)(
-            [](const crow::Request& req,
+            [](const crow::Request& /*req*/,
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
                 asyncResp->res.jsonValue["@odata.type"] =
                     "#ComputerSystemCollection.ComputerSystemCollection";
@@ -2231,9 +2231,8 @@
                 asyncResp->res.jsonValue["Name"] = "Computer System Collection";
 
                 crow::connections::systemBus->async_method_call(
-                    [asyncResp,
-                     &req](const boost::system::error_code ec,
-                           const std::variant<std::string>& /*hostName*/) {
+                    [asyncResp](const boost::system::error_code ec,
+                                const std::variant<std::string>& /*hostName*/) {
                         nlohmann::json& ifaceArray =
                             asyncResp->res.jsonValue["Members"];
                         ifaceArray = nlohmann::json::array();
@@ -2262,7 +2261,7 @@
 /**
  * Function transceives data with dbus directly.
  */
-void doNMI(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+inline void doNMI(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
 {
     constexpr char const* serviceName = "xyz.openbmc_project.Control.Host.NMI";
     constexpr char const* objectPath = "/xyz/openbmc_project/control/host0/nmi";

scripts/parse_registries.py

diff --git a/scripts/parse_registries.py b/scripts/parse_registries.py
index 5f2229c..3d66a03 100755
--- a/scripts/parse_registries.py
+++ b/scripts/parse_registries.py
@@ -50,7 +50,7 @@
 
 
 def clang_format(filename):
-    subprocess.check_call(["clang-format-11", "-i", filename])
+    subprocess.check_call(["clang-format-12", "-i", filename])
 
 
 files = []
@@ -167,7 +167,7 @@
                     privilege_list)
                 operation = operation.lower()
 
-                registry.write("const auto& {}{} = privilegeSet{};\n".format(
+                registry.write("const static auto& {}{} = privilegeSet{};\n".format(
                    operation, entity , privilege_dict[privilege_string][1]))
             registry.write("\n")
         registry.write("} // namespace redfish::privileges\n")