diff --git a/scripts/tools/zap/tests/outputs/all-clusters-app/app-templates/CHIPClusters.h b/scripts/tools/zap/tests/outputs/all-clusters-app/app-templates/CHIPClusters.h
index 8601882bb35715..0b42feede68eab 100644
--- a/scripts/tools/zap/tests/outputs/all-clusters-app/app-templates/CHIPClusters.h
+++ b/scripts/tools/zap/tests/outputs/all-clusters-app/app-templates/CHIPClusters.h
@@ -32,8 +32,7 @@ class DLL_EXPORT OtaSoftwareUpdateProviderCluster : public ClusterBase
 {
 public:
     OtaSoftwareUpdateProviderCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session,
-                                     EndpointId endpoint) :
-        ClusterBase(exchangeManager, session, endpoint)
+                                     EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint)
     {}
     ~OtaSoftwareUpdateProviderCluster() {}
 };
diff --git a/scripts/tools/zap/tests/outputs/lighting-app/app-templates/CHIPClusters.h b/scripts/tools/zap/tests/outputs/lighting-app/app-templates/CHIPClusters.h
index 8601882bb35715..0b42feede68eab 100644
--- a/scripts/tools/zap/tests/outputs/lighting-app/app-templates/CHIPClusters.h
+++ b/scripts/tools/zap/tests/outputs/lighting-app/app-templates/CHIPClusters.h
@@ -32,8 +32,7 @@ class DLL_EXPORT OtaSoftwareUpdateProviderCluster : public ClusterBase
 {
 public:
     OtaSoftwareUpdateProviderCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session,
-                                     EndpointId endpoint) :
-        ClusterBase(exchangeManager, session, endpoint)
+                                     EndpointId endpoint) : ClusterBase(exchangeManager, session, endpoint)
     {}
     ~OtaSoftwareUpdateProviderCluster() {}
 };
diff --git a/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp b/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp
index d9d0c871ba082d..f2a81f98fc819b 100644
--- a/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp
+++ b/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp
@@ -1241,8 +1241,7 @@ void CHIPScenesClusterCopySceneResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, Status, GroupIdentifierFrom, SceneIdentifierFrom);
 }
 CHIPOtaSoftwareUpdateProviderClusterQueryImageResponseCallback::CHIPOtaSoftwareUpdateProviderClusterQueryImageResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPOtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPOtaSoftwareUpdateProviderClusterQueryImageResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -1482,8 +1481,7 @@ void CHIPOtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback::CallbackFn
     env->CallVoidMethod(javaCallbackRef, javaMethod, Action, DelayedActionTime);
 }
 CHIPGeneralCommissioningClusterArmFailSafeResponseCallback::CHIPGeneralCommissioningClusterArmFailSafeResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPGeneralCommissioningClusterArmFailSafeResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPGeneralCommissioningClusterArmFailSafeResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -1547,7 +1545,7 @@ void CHIPGeneralCommissioningClusterArmFailSafeResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, ErrorCode, DebugText);
 }
 CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback::
-    CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback(jobject javaCallback) :
+CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
@@ -1564,8 +1562,8 @@ CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback::
     }
 }
 
-CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback::
-    ~CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback()
+CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback::~
+CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback()
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -1614,7 +1612,7 @@ void CHIPGeneralCommissioningClusterSetRegulatoryConfigResponseCallback::Callbac
     env->CallVoidMethod(javaCallbackRef, javaMethod, ErrorCode, DebugText);
 }
 CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback::
-    CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback(jobject javaCallback) :
+CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
@@ -1631,8 +1629,8 @@ CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback::
     }
 }
 
-CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback::
-    ~CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback()
+CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback::~
+CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback()
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -1681,8 +1679,7 @@ void CHIPGeneralCommissioningClusterCommissioningCompleteResponseCallback::Callb
     env->CallVoidMethod(javaCallbackRef, javaMethod, ErrorCode, DebugText);
 }
 CHIPNetworkCommissioningClusterScanNetworksResponseCallback::CHIPNetworkCommissioningClusterScanNetworksResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPNetworkCommissioningClusterScanNetworksResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPNetworkCommissioningClusterScanNetworksResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -1930,8 +1927,7 @@ void CHIPNetworkCommissioningClusterScanNetworksResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, NetworkingStatus, DebugText, WiFiScanResults, ThreadScanResults);
 }
 CHIPNetworkCommissioningClusterNetworkConfigResponseCallback::CHIPNetworkCommissioningClusterNetworkConfigResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPNetworkCommissioningClusterNetworkConfigResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPNetworkCommissioningClusterNetworkConfigResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -2021,8 +2017,7 @@ void CHIPNetworkCommissioningClusterNetworkConfigResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, NetworkingStatus, DebugText, NetworkIndex);
 }
 CHIPNetworkCommissioningClusterConnectNetworkResponseCallback::CHIPNetworkCommissioningClusterConnectNetworkResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPNetworkCommissioningClusterConnectNetworkResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPNetworkCommissioningClusterConnectNetworkResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -2208,8 +2203,7 @@ void CHIPDiagnosticLogsClusterRetrieveLogsResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, Status, LogContent, UTCTimeStamp, TimeSinceBoot);
 }
 CHIPTimeSynchronizationClusterSetTimeZoneResponseCallback::CHIPTimeSynchronizationClusterSetTimeZoneResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPTimeSynchronizationClusterSetTimeZoneResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPTimeSynchronizationClusterSetTimeZoneResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -2270,8 +2264,7 @@ void CHIPTimeSynchronizationClusterSetTimeZoneResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, DSTOffsetRequired);
 }
 CHIPOperationalCredentialsClusterAttestationResponseCallback::CHIPOperationalCredentialsClusterAttestationResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPOperationalCredentialsClusterAttestationResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPOperationalCredentialsClusterAttestationResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -2336,7 +2329,7 @@ void CHIPOperationalCredentialsClusterAttestationResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, AttestationElements, AttestationSignature);
 }
 CHIPOperationalCredentialsClusterCertificateChainResponseCallback::
-    CHIPOperationalCredentialsClusterCertificateChainResponseCallback(jobject javaCallback) :
+CHIPOperationalCredentialsClusterCertificateChainResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPOperationalCredentialsClusterCertificateChainResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
@@ -2353,8 +2346,8 @@ CHIPOperationalCredentialsClusterCertificateChainResponseCallback::
     }
 }
 
-CHIPOperationalCredentialsClusterCertificateChainResponseCallback::
-    ~CHIPOperationalCredentialsClusterCertificateChainResponseCallback()
+CHIPOperationalCredentialsClusterCertificateChainResponseCallback::~
+CHIPOperationalCredentialsClusterCertificateChainResponseCallback()
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -2554,8 +2547,7 @@ void CHIPOperationalCredentialsClusterNOCResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, StatusCode, FabricIndex, DebugText);
 }
 CHIPGroupKeyManagementClusterKeySetReadResponseCallback::CHIPGroupKeyManagementClusterKeySetReadResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPGroupKeyManagementClusterKeySetReadResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPGroupKeyManagementClusterKeySetReadResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -2733,7 +2725,7 @@ void CHIPGroupKeyManagementClusterKeySetReadResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, GroupKeySet);
 }
 CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback::
-    CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback(jobject javaCallback) :
+CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
@@ -2750,8 +2742,8 @@ CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback::
     }
 }
 
-CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback::
-    ~CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback()
+CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback::~
+CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback()
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -2806,8 +2798,7 @@ void CHIPGroupKeyManagementClusterKeySetReadAllIndicesResponseCallback::Callback
     env->CallVoidMethod(javaCallbackRef, javaMethod, GroupKeySetIDs);
 }
 CHIPIcdManagementClusterRegisterClientResponseCallback::CHIPIcdManagementClusterRegisterClientResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPIcdManagementClusterRegisterClientResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPIcdManagementClusterRegisterClientResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -2868,8 +2859,7 @@ void CHIPIcdManagementClusterRegisterClientResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, ICDCounter);
 }
 CHIPLaundryWasherModeClusterChangeToModeResponseCallback::CHIPLaundryWasherModeClusterChangeToModeResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPLaundryWasherModeClusterChangeToModeResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPLaundryWasherModeClusterChangeToModeResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -2943,7 +2933,7 @@ void CHIPLaundryWasherModeClusterChangeToModeResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, Status, StatusText);
 }
 CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback::
-    CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback(jobject javaCallback) :
+CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
@@ -2960,8 +2950,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCa
     }
 }
 
-CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback::
-    ~CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback()
+CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback::~
+CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterChangeToModeResponseCallback()
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -3244,8 +3234,7 @@ void CHIPDishwasherModeClusterChangeToModeResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, Status, StatusText);
 }
 CHIPOperationalStateClusterOperationalCommandResponseCallback::CHIPOperationalStateClusterOperationalCommandResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPOperationalStateClusterOperationalCommandResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPOperationalStateClusterOperationalCommandResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -3373,8 +3362,8 @@ CHIPRvcOperationalStateClusterOperationalCommandResponseCallback::CHIPRvcOperati
     }
 }
 
-CHIPRvcOperationalStateClusterOperationalCommandResponseCallback::
-    ~CHIPRvcOperationalStateClusterOperationalCommandResponseCallback()
+CHIPRvcOperationalStateClusterOperationalCommandResponseCallback::~
+CHIPRvcOperationalStateClusterOperationalCommandResponseCallback()
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -4157,8 +4146,7 @@ void CHIPDoorLockClusterSetCredentialResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, Status, UserIndex, NextCredentialIndex);
 }
 CHIPDoorLockClusterGetCredentialStatusResponseCallback::CHIPDoorLockClusterGetCredentialStatusResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPDoorLockClusterGetCredentialStatusResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPDoorLockClusterGetCredentialStatusResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -4277,8 +4265,7 @@ void CHIPDoorLockClusterGetCredentialStatusResponseCallback::CallbackFn(
                         NextCredentialIndex);
 }
 CHIPThermostatClusterGetWeeklyScheduleResponseCallback::CHIPThermostatClusterGetWeeklyScheduleResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPThermostatClusterGetWeeklyScheduleResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPThermostatClusterGetWeeklyScheduleResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -4493,8 +4480,7 @@ void CHIPChannelClusterChangeChannelResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, Status, Data);
 }
 CHIPTargetNavigatorClusterNavigateTargetResponseCallback::CHIPTargetNavigatorClusterNavigateTargetResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPTargetNavigatorClusterNavigateTargetResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPTargetNavigatorClusterNavigateTargetResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -4772,8 +4758,7 @@ void CHIPContentLauncherClusterLauncherResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, Status, Data);
 }
 CHIPApplicationLauncherClusterLauncherResponseCallback::CHIPApplicationLauncherClusterLauncherResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPApplicationLauncherClusterLauncherResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPApplicationLauncherClusterLauncherResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -4906,7 +4891,7 @@ void CHIPAccountLoginClusterGetSetupPINResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, SetupPIN);
 }
 CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback::
-    CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback(jobject javaCallback) :
+CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback(jobject javaCallback) :
     Callback::Callback<CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
@@ -4923,8 +4908,8 @@ CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback::
     }
 }
 
-CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback::
-    ~CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback()
+CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback::~
+CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback()
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5001,7 +4986,7 @@ void CHIPElectricalMeasurementClusterGetProfileInfoResponseCommandCallback::Call
     env->CallVoidMethod(javaCallbackRef, javaMethod, profileCount, profileIntervalPeriod, maxNumberOfIntervals, listOfAttributes);
 }
 CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback::
-    CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback(jobject javaCallback) :
+CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback(jobject javaCallback) :
     Callback::Callback<CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
@@ -5018,8 +5003,8 @@ CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback::
     }
 }
 
-CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback::
-    ~CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback()
+CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback::~
+CHIPElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback()
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5171,8 +5156,7 @@ void CHIPUnitTestingClusterTestSpecificResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, returnValue);
 }
 CHIPUnitTestingClusterTestAddArgumentsResponseCallback::CHIPUnitTestingClusterTestAddArgumentsResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPUnitTestingClusterTestAddArgumentsResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPUnitTestingClusterTestAddArgumentsResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5233,8 +5217,7 @@ void CHIPUnitTestingClusterTestAddArgumentsResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, returnValue);
 }
 CHIPUnitTestingClusterTestSimpleArgumentResponseCallback::CHIPUnitTestingClusterTestSimpleArgumentResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPUnitTestingClusterTestSimpleArgumentResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPUnitTestingClusterTestSimpleArgumentResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5295,8 +5278,7 @@ void CHIPUnitTestingClusterTestSimpleArgumentResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, returnValue);
 }
 CHIPUnitTestingClusterTestStructArrayArgumentResponseCallback::CHIPUnitTestingClusterTestStructArrayArgumentResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPUnitTestingClusterTestStructArrayArgumentResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPUnitTestingClusterTestStructArrayArgumentResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5697,8 +5679,7 @@ void CHIPUnitTestingClusterTestStructArrayArgumentResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, arg1, arg2, arg3, arg4, arg5, arg6);
 }
 CHIPUnitTestingClusterTestListInt8UReverseResponseCallback::CHIPUnitTestingClusterTestListInt8UReverseResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPUnitTestingClusterTestListInt8UReverseResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPUnitTestingClusterTestListInt8UReverseResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5833,8 +5814,7 @@ void CHIPUnitTestingClusterTestEnumsResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, arg1, arg2);
 }
 CHIPUnitTestingClusterTestNullableOptionalResponseCallback::CHIPUnitTestingClusterTestNullableOptionalResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPUnitTestingClusterTestNullableOptionalResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPUnitTestingClusterTestNullableOptionalResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5952,7 +5932,7 @@ void CHIPUnitTestingClusterTestNullableOptionalResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, wasPresent, wasNull, value, originalValue);
 }
 CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback::
-    CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback(jobject javaCallback) :
+CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
@@ -5969,8 +5949,8 @@ CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback::
     }
 }
 
-CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback::
-    ~CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback()
+CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback::~
+CHIPUnitTestingClusterTestComplexNullableOptionalResponseCallback()
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -6786,8 +6766,7 @@ void CHIPUnitTestingClusterSimpleStructResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, arg1);
 }
 CHIPUnitTestingClusterTestEmitTestEventResponseCallback::CHIPUnitTestingClusterTestEmitTestEventResponseCallback(
-    jobject javaCallback) :
-    Callback::Callback<CHIPUnitTestingClusterTestEmitTestEventResponseCallbackType>(CallbackFn, this)
+    jobject javaCallback) : Callback::Callback<CHIPUnitTestingClusterTestEmitTestEventResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -6848,7 +6827,7 @@ void CHIPUnitTestingClusterTestEmitTestEventResponseCallback::CallbackFn(
     env->CallVoidMethod(javaCallbackRef, javaMethod, value);
 }
 CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback::
-    CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback(jobject javaCallback) :
+CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback(jobject javaCallback) :
     Callback::Callback<CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallbackType>(CallbackFn, this)
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
@@ -6865,8 +6844,8 @@ CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback::
     }
 }
 
-CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback::
-    ~CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback()
+CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback::~
+CHIPUnitTestingClusterTestEmitTestFabricScopedEventResponseCallback()
 {
     JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp
index b45aa5e51806d2..23ceb0dfcdfa32 100644
--- a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp
+++ b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp
@@ -29,8 +29,7 @@
 
 CHIPIdentifyGeneratedCommandListAttributeCallback::CHIPIdentifyGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPIdentifyClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPIdentifyClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -101,8 +100,7 @@ void CHIPIdentifyGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPIdentifyAcceptedCommandListAttributeCallback::CHIPIdentifyAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPIdentifyClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPIdentifyClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -313,8 +311,7 @@ void CHIPIdentifyAttributeListAttributeCallback::CallbackFn(void * context,
 
 CHIPGroupsGeneratedCommandListAttributeCallback::CHIPGroupsGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPGroupsClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPGroupsClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -385,8 +382,7 @@ void CHIPGroupsGeneratedCommandListAttributeCallback::CallbackFn(void * context,
 
 CHIPGroupsAcceptedCommandListAttributeCallback::CHIPGroupsAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPGroupsClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPGroupsClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -663,8 +659,7 @@ void CHIPScenesLastConfiguredByAttributeCallback::CallbackFn(void * context,
 
 CHIPScenesGeneratedCommandListAttributeCallback::CHIPScenesGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPScenesClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPScenesClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -735,8 +730,7 @@ void CHIPScenesGeneratedCommandListAttributeCallback::CallbackFn(void * context,
 
 CHIPScenesAcceptedCommandListAttributeCallback::CHIPScenesAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPScenesClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPScenesClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -1013,8 +1007,7 @@ void CHIPOnOffStartUpOnOffAttributeCallback::CallbackFn(
 
 CHIPOnOffGeneratedCommandListAttributeCallback::CHIPOnOffGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPOnOffClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPOnOffClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -1294,7 +1287,7 @@ void CHIPOnOffAttributeListAttributeCallback::CallbackFn(void * context,
 }
 
 CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback::
-    CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOnOffSwitchConfigurationClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -1312,8 +1305,8 @@ CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback::
-    ~CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback()
+CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback::~
+CHIPOnOffSwitchConfigurationGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -1385,8 +1378,8 @@ CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback::CHIPOnOffSwitc
     }
 }
 
-CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback::
-    ~CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback()
+CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback::~
+CHIPOnOffSwitchConfigurationAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -1716,8 +1709,7 @@ void CHIPLevelControlOnLevelAttributeCallback::CallbackFn(void * context, const
 
 CHIPLevelControlOnTransitionTimeAttributeCallback::CHIPLevelControlOnTransitionTimeAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPLevelControlClusterOnTransitionTimeAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPLevelControlClusterOnTransitionTimeAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -1784,8 +1776,7 @@ void CHIPLevelControlOnTransitionTimeAttributeCallback::CallbackFn(void * contex
 
 CHIPLevelControlOffTransitionTimeAttributeCallback::CHIPLevelControlOffTransitionTimeAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPLevelControlClusterOffTransitionTimeAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPLevelControlClusterOffTransitionTimeAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -1852,8 +1843,7 @@ void CHIPLevelControlOffTransitionTimeAttributeCallback::CallbackFn(void * conte
 
 CHIPLevelControlDefaultMoveRateAttributeCallback::CHIPLevelControlDefaultMoveRateAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPLevelControlClusterDefaultMoveRateAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPLevelControlClusterDefaultMoveRateAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -2202,8 +2192,7 @@ void CHIPLevelControlEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPLevelControlAttributeListAttributeCallback::CHIPLevelControlAttributeListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPLevelControlClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPLevelControlClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -2418,8 +2407,7 @@ void CHIPBinaryInputBasicAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPBinaryInputBasicEventListAttributeCallback::CHIPBinaryInputBasicEventListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPBinaryInputBasicClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPBinaryInputBasicClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -2490,8 +2478,7 @@ void CHIPBinaryInputBasicEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPBinaryInputBasicAttributeListAttributeCallback::CHIPBinaryInputBasicAttributeListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPBinaryInputBasicClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPBinaryInputBasicClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -2706,8 +2693,7 @@ void CHIPPulseWidthModulationAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPPulseWidthModulationEventListAttributeCallback::CHIPPulseWidthModulationEventListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPPulseWidthModulationClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPPulseWidthModulationClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -3291,8 +3277,7 @@ void CHIPDescriptorTagListAttributeCallback::CallbackFn(
 
 CHIPDescriptorGeneratedCommandListAttributeCallback::CHIPDescriptorGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPDescriptorClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPDescriptorClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -3363,8 +3348,7 @@ void CHIPDescriptorGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPDescriptorAcceptedCommandListAttributeCallback::CHIPDescriptorAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPDescriptorClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPDescriptorClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -3732,8 +3716,7 @@ void CHIPBindingBindingAttributeCallback::CallbackFn(
 
 CHIPBindingGeneratedCommandListAttributeCallback::CHIPBindingGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPBindingClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPBindingClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -3804,8 +3787,7 @@ void CHIPBindingGeneratedCommandListAttributeCallback::CallbackFn(void * context
 
 CHIPBindingAcceptedCommandListAttributeCallback::CHIPBindingAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPBindingClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPBindingClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -4540,8 +4522,7 @@ void CHIPAccessControlEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPAccessControlAttributeListAttributeCallback::CHIPAccessControlAttributeListAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPAccessControlClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPAccessControlClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -4851,8 +4832,7 @@ void CHIPActionsEndpointListsAttributeCallback::CallbackFn(
 
 CHIPActionsGeneratedCommandListAttributeCallback::CHIPActionsGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPActionsClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPActionsClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -4923,8 +4903,7 @@ void CHIPActionsGeneratedCommandListAttributeCallback::CallbackFn(void * context
 
 CHIPActionsAcceptedCommandListAttributeCallback::CHIPActionsAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPActionsClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPActionsClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5279,8 +5258,7 @@ void CHIPBasicInformationAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPBasicInformationEventListAttributeCallback::CHIPBasicInformationEventListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPBasicInformationClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPBasicInformationClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5351,8 +5329,7 @@ void CHIPBasicInformationEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPBasicInformationAttributeListAttributeCallback::CHIPBasicInformationAttributeListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPBasicInformationClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPBasicInformationClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5422,7 +5399,7 @@ void CHIPBasicInformationAttributeListAttributeCallback::CallbackFn(
 }
 
 CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback::
-    CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOtaSoftwareUpdateProviderClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -5440,8 +5417,8 @@ CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback::
-    ~CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback()
+CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback::~
+CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5495,7 +5472,7 @@ void CHIPOtaSoftwareUpdateProviderGeneratedCommandListAttributeCallback::Callbac
 }
 
 CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback::
-    CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOtaSoftwareUpdateProviderClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -5513,8 +5490,8 @@ CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback::
-    ~CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback()
+CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback::~
+CHIPOtaSoftwareUpdateProviderAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5712,7 +5689,7 @@ void CHIPOtaSoftwareUpdateProviderAttributeListAttributeCallback::CallbackFn(
 }
 
 CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback::
-    CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOtaSoftwareUpdateRequestorClusterDefaultOTAProvidersAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -5730,8 +5707,8 @@ CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback::
     }
 }
 
-CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback::
-    ~CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback()
+CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback::~
+CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5823,7 +5800,7 @@ void CHIPOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeCallback::Callbac
 }
 
 CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback::
-    CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOtaSoftwareUpdateRequestorClusterUpdateStateProgressAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -5841,8 +5818,8 @@ CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback::
     }
 }
 
-CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback::
-    ~CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback()
+CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback::~
+CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5892,7 +5869,7 @@ void CHIPOtaSoftwareUpdateRequestorUpdateStateProgressAttributeCallback::Callbac
 }
 
 CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback::
-    CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOtaSoftwareUpdateRequestorClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -5910,8 +5887,8 @@ CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback::
-    ~CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback()
+CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback::~
+CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -5965,7 +5942,7 @@ void CHIPOtaSoftwareUpdateRequestorGeneratedCommandListAttributeCallback::Callba
 }
 
 CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback::
-    CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOtaSoftwareUpdateRequestorClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -5983,8 +5960,8 @@ CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback::
-    ~CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback()
+CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback::~
+CHIPOtaSoftwareUpdateRequestorAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -6250,7 +6227,7 @@ void CHIPLocalizationConfigurationSupportedLocalesAttributeCallback::CallbackFn(
 }
 
 CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback::
-    CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPLocalizationConfigurationClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -6268,8 +6245,8 @@ CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback::
-    ~CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback()
+CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback::~
+CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -6323,7 +6300,7 @@ void CHIPLocalizationConfigurationGeneratedCommandListAttributeCallback::Callbac
 }
 
 CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback::
-    CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPLocalizationConfigurationClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -6341,8 +6318,8 @@ CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback::
-    ~CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback()
+CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback::~
+CHIPLocalizationConfigurationAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -6540,7 +6517,7 @@ void CHIPLocalizationConfigurationAttributeListAttributeCallback::CallbackFn(
 }
 
 CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback::
-    CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -6558,8 +6535,8 @@ CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback::
     }
 }
 
-CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback::
-    ~CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback()
+CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback::~
+CHIPTimeFormatLocalizationSupportedCalendarTypesAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -7046,8 +7023,7 @@ void CHIPUnitLocalizationAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPUnitLocalizationEventListAttributeCallback::CHIPUnitLocalizationEventListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitLocalizationClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitLocalizationClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -7118,8 +7094,7 @@ void CHIPUnitLocalizationEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitLocalizationAttributeListAttributeCallback::CHIPUnitLocalizationAttributeListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitLocalizationClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitLocalizationClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -7261,7 +7236,7 @@ void CHIPPowerSourceConfigurationSourcesAttributeCallback::CallbackFn(void * con
 }
 
 CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback::
-    CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPowerSourceConfigurationClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -7279,8 +7254,8 @@ CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback::
-    ~CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback()
+CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback::~
+CHIPPowerSourceConfigurationGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -7352,8 +7327,8 @@ CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback::CHIPPowerSourc
     }
 }
 
-CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback::
-    ~CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback()
+CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback::~
+CHIPPowerSourceConfigurationAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -7756,8 +7731,7 @@ void CHIPPowerSourceWiredAssessedCurrentAttributeCallback::CallbackFn(void * con
 
 CHIPPowerSourceActiveWiredFaultsAttributeCallback::CHIPPowerSourceActiveWiredFaultsAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPPowerSourceClusterActiveWiredFaultsAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPPowerSourceClusterActiveWiredFaultsAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -7893,8 +7867,7 @@ void CHIPPowerSourceBatVoltageAttributeCallback::CallbackFn(void * context, cons
 
 CHIPPowerSourceBatPercentRemainingAttributeCallback::CHIPPowerSourceBatPercentRemainingAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPPowerSourceClusterBatPercentRemainingAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPPowerSourceClusterBatPercentRemainingAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -7961,8 +7934,7 @@ void CHIPPowerSourceBatPercentRemainingAttributeCallback::CallbackFn(void * cont
 
 CHIPPowerSourceBatTimeRemainingAttributeCallback::CHIPPowerSourceBatTimeRemainingAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPPowerSourceClusterBatTimeRemainingAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPPowerSourceClusterBatTimeRemainingAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -8029,8 +8001,7 @@ void CHIPPowerSourceBatTimeRemainingAttributeCallback::CallbackFn(void * context
 
 CHIPPowerSourceActiveBatFaultsAttributeCallback::CHIPPowerSourceActiveBatFaultsAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPPowerSourceClusterActiveBatFaultsAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPPowerSourceClusterActiveBatFaultsAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -8101,8 +8072,7 @@ void CHIPPowerSourceActiveBatFaultsAttributeCallback::CallbackFn(
 
 CHIPPowerSourceBatTimeToFullChargeAttributeCallback::CHIPPowerSourceBatTimeToFullChargeAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPPowerSourceClusterBatTimeToFullChargeAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPPowerSourceClusterBatTimeToFullChargeAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -8169,8 +8139,7 @@ void CHIPPowerSourceBatTimeToFullChargeAttributeCallback::CallbackFn(void * cont
 
 CHIPPowerSourceBatChargingCurrentAttributeCallback::CHIPPowerSourceBatChargingCurrentAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPPowerSourceClusterBatChargingCurrentAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPPowerSourceClusterBatChargingCurrentAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -8451,8 +8420,7 @@ void CHIPPowerSourceGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPPowerSourceAcceptedCommandListAttributeCallback::CHIPPowerSourceAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPPowerSourceClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPPowerSourceClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -8807,8 +8775,7 @@ void CHIPGeneralCommissioningAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPGeneralCommissioningEventListAttributeCallback::CHIPGeneralCommissioningEventListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPGeneralCommissioningClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPGeneralCommissioningClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -8951,8 +8918,7 @@ void CHIPGeneralCommissioningAttributeListAttributeCallback::CallbackFn(
 
 CHIPNetworkCommissioningNetworksAttributeCallback::CHIPNetworkCommissioningNetworksAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPNetworkCommissioningClusterNetworksAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPNetworkCommissioningClusterNetworksAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -9471,8 +9437,7 @@ void CHIPNetworkCommissioningAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPNetworkCommissioningEventListAttributeCallback::CHIPNetworkCommissioningEventListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPNetworkCommissioningClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPNetworkCommissioningClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -9829,8 +9794,7 @@ void CHIPDiagnosticLogsEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPDiagnosticLogsAttributeListAttributeCallback::CHIPDiagnosticLogsAttributeListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPDiagnosticLogsClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPDiagnosticLogsClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -10433,8 +10397,7 @@ void CHIPGeneralDiagnosticsAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPGeneralDiagnosticsEventListAttributeCallback::CHIPGeneralDiagnosticsEventListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPGeneralDiagnosticsClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPGeneralDiagnosticsClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -10882,8 +10845,7 @@ void CHIPSoftwareDiagnosticsAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPSoftwareDiagnosticsEventListAttributeCallback::CHIPSoftwareDiagnosticsEventListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPSoftwareDiagnosticsClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPSoftwareDiagnosticsClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -11226,8 +11188,7 @@ void CHIPThreadNetworkDiagnosticsNetworkNameAttributeCallback::CallbackFn(
 
 CHIPThreadNetworkDiagnosticsPanIdAttributeCallback::CHIPThreadNetworkDiagnosticsPanIdAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPThreadNetworkDiagnosticsClusterPanIdAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThreadNetworkDiagnosticsClusterPanIdAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -12272,8 +12233,7 @@ void CHIPThreadNetworkDiagnosticsPendingTimestampAttributeCallback::CallbackFn(
 
 CHIPThreadNetworkDiagnosticsDelayAttributeCallback::CHIPThreadNetworkDiagnosticsDelayAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPThreadNetworkDiagnosticsClusterDelayAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThreadNetworkDiagnosticsClusterDelayAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -12406,7 +12366,7 @@ void CHIPThreadNetworkDiagnosticsChannelPage0MaskAttributeCallback::CallbackFn(
 }
 
 CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback::
-    CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -12424,8 +12384,8 @@ CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback::
     }
 }
 
-CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback::
-    ~CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback()
+CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback::~
+CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -12480,7 +12440,7 @@ void CHIPThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeCallback::Callb
 }
 
 CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback::
-    CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPThreadNetworkDiagnosticsClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -12498,8 +12458,8 @@ CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback::
-    ~CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback()
+CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback::~
+CHIPThreadNetworkDiagnosticsGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -12571,8 +12531,8 @@ CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback::CHIPThreadNetw
     }
 }
 
-CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback::
-    ~CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback()
+CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback::~
+CHIPThreadNetworkDiagnosticsAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -12771,8 +12731,7 @@ void CHIPThreadNetworkDiagnosticsAttributeListAttributeCallback::CallbackFn(
 
 CHIPWiFiNetworkDiagnosticsBssidAttributeCallback::CHIPWiFiNetworkDiagnosticsBssidAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPWiFiNetworkDiagnosticsClusterBssidAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPWiFiNetworkDiagnosticsClusterBssidAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -13042,8 +13001,7 @@ void CHIPWiFiNetworkDiagnosticsChannelNumberAttributeCallback::CallbackFn(void *
 
 CHIPWiFiNetworkDiagnosticsRssiAttributeCallback::CHIPWiFiNetworkDiagnosticsRssiAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPWiFiNetworkDiagnosticsClusterRssiAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPWiFiNetworkDiagnosticsClusterRssiAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -13245,7 +13203,7 @@ void CHIPWiFiNetworkDiagnosticsBeaconRxCountAttributeCallback::CallbackFn(void *
 }
 
 CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback::
-    CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPWiFiNetworkDiagnosticsClusterPacketMulticastRxCountAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -13263,8 +13221,8 @@ CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback::
     }
 }
 
-CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback::
-    ~CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback()
+CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback::~
+CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -13314,7 +13272,7 @@ void CHIPWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeCallback::Callback
 }
 
 CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback::
-    CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPWiFiNetworkDiagnosticsClusterPacketMulticastTxCountAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -13332,8 +13290,8 @@ CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback::
     }
 }
 
-CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback::
-    ~CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback()
+CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback::~
+CHIPWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -14147,7 +14105,7 @@ void CHIPEthernetNetworkDiagnosticsCarrierDetectAttributeCallback::CallbackFn(vo
 }
 
 CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback::
-    CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPEthernetNetworkDiagnosticsClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -14165,8 +14123,8 @@ CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback::
-    ~CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback()
+CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback::~
+CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -14220,7 +14178,7 @@ void CHIPEthernetNetworkDiagnosticsGeneratedCommandListAttributeCallback::Callba
 }
 
 CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback::
-    CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPEthernetNetworkDiagnosticsClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -14238,8 +14196,8 @@ CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback::
-    ~CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback()
+CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback::~
+CHIPEthernetNetworkDiagnosticsAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -14438,8 +14396,7 @@ void CHIPEthernetNetworkDiagnosticsAttributeListAttributeCallback::CallbackFn(
 
 CHIPTimeSynchronizationUTCTimeAttributeCallback::CHIPTimeSynchronizationUTCTimeAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPTimeSynchronizationClusterUTCTimeAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPTimeSynchronizationClusterUTCTimeAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -14506,8 +14463,7 @@ void CHIPTimeSynchronizationUTCTimeAttributeCallback::CallbackFn(void * context,
 
 CHIPTimeSynchronizationDefaultNTPAttributeCallback::CHIPTimeSynchronizationDefaultNTPAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPTimeSynchronizationClusterDefaultNTPAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPTimeSynchronizationClusterDefaultNTPAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -14570,8 +14526,7 @@ void CHIPTimeSynchronizationDefaultNTPAttributeCallback::CallbackFn(void * conte
 
 CHIPTimeSynchronizationTimeZoneAttributeCallback::CHIPTimeSynchronizationTimeZoneAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPTimeSynchronizationClusterTimeZoneAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPTimeSynchronizationClusterTimeZoneAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -14684,8 +14639,7 @@ void CHIPTimeSynchronizationTimeZoneAttributeCallback::CallbackFn(
 
 CHIPTimeSynchronizationDSTOffsetAttributeCallback::CHIPTimeSynchronizationDSTOffsetAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPTimeSynchronizationClusterDSTOffsetAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPTimeSynchronizationClusterDSTOffsetAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -14800,8 +14754,7 @@ void CHIPTimeSynchronizationDSTOffsetAttributeCallback::CallbackFn(
 
 CHIPTimeSynchronizationLocalTimeAttributeCallback::CHIPTimeSynchronizationLocalTimeAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPTimeSynchronizationClusterLocalTimeAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPTimeSynchronizationClusterLocalTimeAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -15012,8 +14965,7 @@ void CHIPTimeSynchronizationAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPTimeSynchronizationEventListAttributeCallback::CHIPTimeSynchronizationEventListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPTimeSynchronizationClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPTimeSynchronizationClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -15155,7 +15107,7 @@ void CHIPTimeSynchronizationAttributeListAttributeCallback::CallbackFn(
 }
 
 CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback::
-    CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPBridgedDeviceBasicInformationClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -15173,8 +15125,8 @@ CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback::
-    ~CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback()
+CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback::~
+CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -15228,7 +15180,7 @@ void CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback::Cal
 }
 
 CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback::
-    CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPBridgedDeviceBasicInformationClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -15246,8 +15198,8 @@ CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback::
-    ~CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback()
+CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback::~
+CHIPBridgedDeviceBasicInformationAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -15446,8 +15398,7 @@ void CHIPBridgedDeviceBasicInformationAttributeListAttributeCallback::CallbackFn
 
 CHIPSwitchGeneratedCommandListAttributeCallback::CHIPSwitchGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPSwitchClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPSwitchClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -15518,8 +15469,7 @@ void CHIPSwitchGeneratedCommandListAttributeCallback::CallbackFn(void * context,
 
 CHIPSwitchAcceptedCommandListAttributeCallback::CHIPSwitchAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPSwitchClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPSwitchClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -15865,7 +15815,7 @@ void CHIPAdministratorCommissioningAdminVendorIdAttributeCallback::CallbackFn(
 }
 
 CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback::
-    CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPAdministratorCommissioningClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -15883,8 +15833,8 @@ CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback::
-    ~CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback()
+CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback::~
+CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -15938,7 +15888,7 @@ void CHIPAdministratorCommissioningGeneratedCommandListAttributeCallback::Callba
 }
 
 CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback::
-    CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPAdministratorCommissioningClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -15956,8 +15906,8 @@ CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback::
-    ~CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback()
+CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback::~
+CHIPAdministratorCommissioningAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -16156,8 +16106,7 @@ void CHIPAdministratorCommissioningAttributeListAttributeCallback::CallbackFn(
 
 CHIPOperationalCredentialsNOCsAttributeCallback::CHIPOperationalCredentialsNOCsAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPOperationalCredentialsClusterNOCsAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPOperationalCredentialsClusterNOCsAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -16267,8 +16216,7 @@ void CHIPOperationalCredentialsNOCsAttributeCallback::CallbackFn(
 
 CHIPOperationalCredentialsFabricsAttributeCallback::CHIPOperationalCredentialsFabricsAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPOperationalCredentialsClusterFabricsAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPOperationalCredentialsClusterFabricsAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -16392,7 +16340,7 @@ void CHIPOperationalCredentialsFabricsAttributeCallback::CallbackFn(
 }
 
 CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback::
-    CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOperationalCredentialsClusterTrustedRootCertificatesAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -16410,8 +16358,8 @@ CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback::
     }
 }
 
-CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback::
-    ~CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback()
+CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback::~
+CHIPOperationalCredentialsTrustedRootCertificatesAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -16753,8 +16701,7 @@ void CHIPOperationalCredentialsAttributeListAttributeCallback::CallbackFn(
 
 CHIPGroupKeyManagementGroupKeyMapAttributeCallback::CHIPGroupKeyManagementGroupKeyMapAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPGroupKeyManagementClusterGroupKeyMapAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPGroupKeyManagementClusterGroupKeyMapAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -16862,8 +16809,7 @@ void CHIPGroupKeyManagementGroupKeyMapAttributeCallback::CallbackFn(
 
 CHIPGroupKeyManagementGroupTableAttributeCallback::CHIPGroupKeyManagementGroupTableAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPGroupKeyManagementClusterGroupTableAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPGroupKeyManagementClusterGroupTableAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -17136,8 +17082,7 @@ void CHIPGroupKeyManagementAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPGroupKeyManagementEventListAttributeCallback::CHIPGroupKeyManagementEventListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPGroupKeyManagementClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPGroupKeyManagementClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -17368,8 +17313,7 @@ void CHIPFixedLabelLabelListAttributeCallback::CallbackFn(
 
 CHIPFixedLabelGeneratedCommandListAttributeCallback::CHIPFixedLabelGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPFixedLabelClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPFixedLabelClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -17440,8 +17384,7 @@ void CHIPFixedLabelGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPFixedLabelAcceptedCommandListAttributeCallback::CHIPFixedLabelAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPFixedLabelClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPFixedLabelClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -17740,8 +17683,7 @@ void CHIPUserLabelLabelListAttributeCallback::CallbackFn(
 
 CHIPUserLabelGeneratedCommandListAttributeCallback::CHIPUserLabelGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPUserLabelClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUserLabelClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -17812,8 +17754,7 @@ void CHIPUserLabelGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPUserLabelAcceptedCommandListAttributeCallback::CHIPUserLabelAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPUserLabelClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUserLabelClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -18168,8 +18109,7 @@ void CHIPProxyConfigurationAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPProxyConfigurationEventListAttributeCallback::CHIPProxyConfigurationEventListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPProxyConfigurationClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPProxyConfigurationClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -18526,8 +18466,7 @@ void CHIPProxyDiscoveryEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPProxyDiscoveryAttributeListAttributeCallback::CHIPProxyDiscoveryAttributeListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPProxyDiscoveryClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPProxyDiscoveryClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -18598,8 +18537,7 @@ void CHIPProxyDiscoveryAttributeListAttributeCallback::CallbackFn(
 
 CHIPProxyValidGeneratedCommandListAttributeCallback::CHIPProxyValidGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPProxyValidClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPProxyValidClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -18670,8 +18608,7 @@ void CHIPProxyValidGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPProxyValidAcceptedCommandListAttributeCallback::CHIPProxyValidAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPProxyValidClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPProxyValidClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -19096,8 +19033,7 @@ void CHIPBooleanStateEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPBooleanStateAttributeListAttributeCallback::CHIPBooleanStateAttributeListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPBooleanStateClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPBooleanStateClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -19168,8 +19104,7 @@ void CHIPBooleanStateAttributeListAttributeCallback::CallbackFn(void * context,
 
 CHIPIcdManagementRegisteredClientsAttributeCallback::CHIPIcdManagementRegisteredClientsAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPIcdManagementClusterRegisteredClientsAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPIcdManagementClusterRegisteredClientsAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -19492,8 +19427,7 @@ void CHIPIcdManagementEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPIcdManagementAttributeListAttributeCallback::CHIPIcdManagementAttributeListAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPIcdManagementClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPIcdManagementClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -19564,8 +19498,7 @@ void CHIPIcdManagementAttributeListAttributeCallback::CallbackFn(
 
 CHIPModeSelectStandardNamespaceAttributeCallback::CHIPModeSelectStandardNamespaceAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPModeSelectClusterStandardNamespaceAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPModeSelectClusterStandardNamespaceAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -19898,8 +19831,7 @@ void CHIPModeSelectOnModeAttributeCallback::CallbackFn(void * context, const chi
 
 CHIPModeSelectGeneratedCommandListAttributeCallback::CHIPModeSelectGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPModeSelectClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPModeSelectClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -19970,8 +19902,7 @@ void CHIPModeSelectGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPModeSelectAcceptedCommandListAttributeCallback::CHIPModeSelectAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPModeSelectClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPModeSelectClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -20330,8 +20261,7 @@ void CHIPLaundryWasherModeSupportedModesAttributeCallback::CallbackFn(
 
 CHIPLaundryWasherModeStartUpModeAttributeCallback::CHIPLaundryWasherModeStartUpModeAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPLaundryWasherModeClusterStartUpModeAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPLaundryWasherModeClusterStartUpModeAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -20607,8 +20537,7 @@ void CHIPLaundryWasherModeAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPLaundryWasherModeEventListAttributeCallback::CHIPLaundryWasherModeEventListAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPLaundryWasherModeClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPLaundryWasherModeClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -20679,8 +20608,7 @@ void CHIPLaundryWasherModeEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPLaundryWasherModeAttributeListAttributeCallback::CHIPLaundryWasherModeAttributeListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPLaundryWasherModeClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPLaundryWasherModeClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -20750,7 +20678,7 @@ void CHIPLaundryWasherModeAttributeListAttributeCallback::CallbackFn(
 }
 
 CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback::
-    CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterSupportedModesAttributeCallbackType>(
         CallbackFn, this),
     keepAlive(keepAlive)
@@ -20769,8 +20697,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallba
     }
 }
 
-CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback::
-    ~CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback()
+CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback::~
+CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -20909,7 +20837,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeSupportedModesAttributeC
 }
 
 CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback::
-    CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterStartUpModeAttributeCallbackType>(CallbackFn,
                                                                                                                          this),
     keepAlive(keepAlive)
@@ -20928,8 +20856,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback:
     }
 }
 
-CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback::
-    ~CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback()
+CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback::~
+CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -20980,7 +20908,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeStartUpModeAttributeCall
 }
 
 CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback::
-    CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterOnModeAttributeCallbackType>(CallbackFn,
                                                                                                                     this),
     keepAlive(keepAlive)
@@ -20999,8 +20927,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback::
     }
 }
 
-CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback::
-    ~CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback()
+CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback::~
+CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -21051,7 +20979,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeOnModeAttributeCallback:
 }
 
 CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback::
-    CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterGeneratedCommandListAttributeCallbackType>(
         CallbackFn, this),
     keepAlive(keepAlive)
@@ -21070,8 +20998,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttribute
     }
 }
 
-CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback::
-    ~CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback()
+CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback::~
+CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -21128,7 +21056,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeGeneratedCommandListAttr
 }
 
 CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback::
-    CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterAcceptedCommandListAttributeCallbackType>(
         CallbackFn, this),
     keepAlive(keepAlive)
@@ -21147,8 +21075,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeC
     }
 }
 
-CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback::
-    ~CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback()
+CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback::~
+CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -21205,7 +21133,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeAcceptedCommandListAttri
 }
 
 CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback::
-    CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterEventListAttributeCallbackType>(CallbackFn,
                                                                                                                        this),
     keepAlive(keepAlive)
@@ -21224,8 +21152,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback::
     }
 }
 
-CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback::
-    ~CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback()
+CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback::~
+CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -21280,7 +21208,7 @@ void CHIPRefrigeratorAndTemperatureControlledCabinetModeEventListAttributeCallba
 }
 
 CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback::
-    CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRefrigeratorAndTemperatureControlledCabinetModeClusterAttributeListAttributeCallbackType>(
         CallbackFn, this),
     keepAlive(keepAlive)
@@ -21299,8 +21227,8 @@ CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallbac
     }
 }
 
-CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback::
-    ~CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback()
+CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback::~
+CHIPRefrigeratorAndTemperatureControlledCabinetModeAttributeListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -21709,8 +21637,7 @@ void CHIPLaundryWasherControlsAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPLaundryWasherControlsEventListAttributeCallback::CHIPLaundryWasherControlsEventListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPLaundryWasherControlsClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPLaundryWasherControlsClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -22063,8 +21990,7 @@ void CHIPRvcRunModeOnModeAttributeCallback::CallbackFn(void * context, const chi
 
 CHIPRvcRunModeGeneratedCommandListAttributeCallback::CHIPRvcRunModeGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPRvcRunModeClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPRvcRunModeClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -22135,8 +22061,7 @@ void CHIPRvcRunModeGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPRvcRunModeAcceptedCommandListAttributeCallback::CHIPRvcRunModeAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPRvcRunModeClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPRvcRunModeClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -22347,8 +22272,7 @@ void CHIPRvcRunModeAttributeListAttributeCallback::CallbackFn(void * context,
 
 CHIPRvcCleanModeSupportedModesAttributeCallback::CHIPRvcCleanModeSupportedModesAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPRvcCleanModeClusterSupportedModesAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPRvcCleanModeClusterSupportedModesAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -22773,8 +22697,7 @@ void CHIPRvcCleanModeEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPRvcCleanModeAttributeListAttributeCallback::CHIPRvcCleanModeAttributeListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPRvcCleanModeClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPRvcCleanModeClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -22844,7 +22767,7 @@ void CHIPRvcCleanModeAttributeListAttributeCallback::CallbackFn(void * context,
 }
 
 CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback::
-    CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPTemperatureControlClusterSupportedTemperatureLevelsAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -22862,8 +22785,8 @@ CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback::
     }
 }
 
-CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback::
-    ~CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback()
+CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback::~
+CHIPTemperatureControlSupportedTemperatureLevelsAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -23058,8 +22981,7 @@ void CHIPTemperatureControlAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPTemperatureControlEventListAttributeCallback::CHIPTemperatureControlEventListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPTemperatureControlClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPTemperatureControlClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -23346,8 +23268,7 @@ void CHIPRefrigeratorAlarmAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPRefrigeratorAlarmEventListAttributeCallback::CHIPRefrigeratorAlarmEventListAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPRefrigeratorAlarmClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPRefrigeratorAlarmClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -23418,8 +23339,7 @@ void CHIPRefrigeratorAlarmEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPRefrigeratorAlarmAttributeListAttributeCallback::CHIPRefrigeratorAlarmAttributeListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPRefrigeratorAlarmClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPRefrigeratorAlarmClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -23490,8 +23410,7 @@ void CHIPRefrigeratorAlarmAttributeListAttributeCallback::CallbackFn(
 
 CHIPDishwasherModeSupportedModesAttributeCallback::CHIPDishwasherModeSupportedModesAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPDishwasherModeClusterSupportedModesAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPDishwasherModeClusterSupportedModesAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -23637,8 +23556,7 @@ void CHIPDishwasherModeSupportedModesAttributeCallback::CallbackFn(
 
 CHIPDishwasherModeStartUpModeAttributeCallback::CHIPDishwasherModeStartUpModeAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPDishwasherModeClusterStartUpModeAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPDishwasherModeClusterStartUpModeAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -23984,8 +23902,7 @@ void CHIPDishwasherModeEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPDishwasherModeAttributeListAttributeCallback::CHIPDishwasherModeAttributeListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPDishwasherModeClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPDishwasherModeClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -24056,8 +23973,7 @@ void CHIPDishwasherModeAttributeListAttributeCallback::CallbackFn(
 
 CHIPAirQualityGeneratedCommandListAttributeCallback::CHIPAirQualityGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPAirQualityClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPAirQualityClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -24128,8 +24044,7 @@ void CHIPAirQualityGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPAirQualityAcceptedCommandListAttributeCallback::CHIPAirQualityAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPAirQualityClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPAirQualityClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -24554,8 +24469,7 @@ void CHIPSmokeCoAlarmEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPSmokeCoAlarmAttributeListAttributeCallback::CHIPSmokeCoAlarmAttributeListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPSmokeCoAlarmClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPSmokeCoAlarmClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -24840,8 +24754,7 @@ void CHIPDishwasherAlarmEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPDishwasherAlarmAttributeListAttributeCallback::CHIPDishwasherAlarmAttributeListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPDishwasherAlarmClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPDishwasherAlarmClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -24912,8 +24825,7 @@ void CHIPDishwasherAlarmAttributeListAttributeCallback::CallbackFn(
 
 CHIPOperationalStatePhaseListAttributeCallback::CHIPOperationalStatePhaseListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPOperationalStateClusterPhaseListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPOperationalStateClusterPhaseListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -24987,8 +24899,7 @@ void CHIPOperationalStatePhaseListAttributeCallback::CallbackFn(
 
 CHIPOperationalStateCurrentPhaseAttributeCallback::CHIPOperationalStateCurrentPhaseAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPOperationalStateClusterCurrentPhaseAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPOperationalStateClusterCurrentPhaseAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -25055,8 +24966,7 @@ void CHIPOperationalStateCurrentPhaseAttributeCallback::CallbackFn(void * contex
 
 CHIPOperationalStateCountdownTimeAttributeCallback::CHIPOperationalStateCountdownTimeAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPOperationalStateClusterCountdownTimeAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPOperationalStateClusterCountdownTimeAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -25376,8 +25286,7 @@ void CHIPOperationalStateAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPOperationalStateEventListAttributeCallback::CHIPOperationalStateEventListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPOperationalStateClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPOperationalStateClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -25448,8 +25357,7 @@ void CHIPOperationalStateEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPOperationalStateAttributeListAttributeCallback::CHIPOperationalStateAttributeListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPOperationalStateClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPOperationalStateClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -25520,8 +25428,7 @@ void CHIPOperationalStateAttributeListAttributeCallback::CallbackFn(
 
 CHIPRvcOperationalStatePhaseListAttributeCallback::CHIPRvcOperationalStatePhaseListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPRvcOperationalStateClusterPhaseListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPRvcOperationalStateClusterPhaseListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -25984,8 +25891,7 @@ void CHIPRvcOperationalStateAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPRvcOperationalStateEventListAttributeCallback::CHIPRvcOperationalStateEventListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPRvcOperationalStateClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPRvcOperationalStateClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -26439,8 +26345,7 @@ void CHIPHepaFilterMonitoringAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPHepaFilterMonitoringEventListAttributeCallback::CHIPHepaFilterMonitoringEventListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPHepaFilterMonitoringClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPHepaFilterMonitoringClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -26582,7 +26487,7 @@ void CHIPHepaFilterMonitoringAttributeListAttributeCallback::CallbackFn(
 }
 
 CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback::
-    CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPActivatedCarbonFilterMonitoringClusterLastChangedTimeAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -26600,8 +26505,8 @@ CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback::
     }
 }
 
-CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback::
-    ~CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback()
+CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback::~
+CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -26651,7 +26556,7 @@ void CHIPActivatedCarbonFilterMonitoringLastChangedTimeAttributeCallback::Callba
 }
 
 CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback::
-    CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPActivatedCarbonFilterMonitoringClusterReplacementProductListAttributeCallbackType>(CallbackFn,
                                                                                                                     this),
     keepAlive(keepAlive)
@@ -26670,8 +26575,8 @@ CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback::
     }
 }
 
-CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback::
-    ~CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback()
+CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback::~
+CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -26754,7 +26659,7 @@ void CHIPActivatedCarbonFilterMonitoringReplacementProductListAttributeCallback:
 }
 
 CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback::
-    CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPActivatedCarbonFilterMonitoringClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -26772,8 +26677,8 @@ CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback::
-    ~CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback()
+CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback::~
+CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -26827,7 +26732,7 @@ void CHIPActivatedCarbonFilterMonitoringGeneratedCommandListAttributeCallback::C
 }
 
 CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback::
-    CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPActivatedCarbonFilterMonitoringClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -26845,8 +26750,8 @@ CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback::
-    ~CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback()
+CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback::~
+CHIPActivatedCarbonFilterMonitoringAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -26972,7 +26877,7 @@ void CHIPActivatedCarbonFilterMonitoringEventListAttributeCallback::CallbackFn(
 }
 
 CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback::
-    CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPActivatedCarbonFilterMonitoringClusterAttributeListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -26990,8 +26895,8 @@ CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback::
     }
 }
 
-CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback::
-    ~CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback()
+CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback::~
+CHIPActivatedCarbonFilterMonitoringAttributeListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -27178,8 +27083,7 @@ void CHIPDoorLockDoorStateAttributeCallback::CallbackFn(
 
 CHIPDoorLockGeneratedCommandListAttributeCallback::CHIPDoorLockGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPDoorLockClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPDoorLockClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -27250,8 +27154,7 @@ void CHIPDoorLockGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPDoorLockAcceptedCommandListAttributeCallback::CHIPDoorLockAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPDoorLockClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPDoorLockClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -27615,8 +27518,8 @@ CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback::CHIPWindowCove
     }
 }
 
-CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback::
-    ~CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback()
+CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback::~
+CHIPWindowCoveringCurrentPositionLiftPercentageAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -27684,8 +27587,8 @@ CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback::CHIPWindowCove
     }
 }
 
-CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback::
-    ~CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback()
+CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback::~
+CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -27735,7 +27638,7 @@ void CHIPWindowCoveringCurrentPositionTiltPercentageAttributeCallback::CallbackF
 }
 
 CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback::
-    CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPWindowCoveringClusterTargetPositionLiftPercent100thsAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -27753,8 +27656,8 @@ CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback::
     }
 }
 
-CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback::
-    ~CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback()
+CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback::~
+CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -27804,7 +27707,7 @@ void CHIPWindowCoveringTargetPositionLiftPercent100thsAttributeCallback::Callbac
 }
 
 CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback::
-    CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPWindowCoveringClusterTargetPositionTiltPercent100thsAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -27822,8 +27725,8 @@ CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback::
     }
 }
 
-CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback::
-    ~CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback()
+CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback::~
+CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -27873,7 +27776,7 @@ void CHIPWindowCoveringTargetPositionTiltPercent100thsAttributeCallback::Callbac
 }
 
 CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback::
-    CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPWindowCoveringClusterCurrentPositionLiftPercent100thsAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -27891,8 +27794,8 @@ CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback::
     }
 }
 
-CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback::
-    ~CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback()
+CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback::~
+CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -27942,7 +27845,7 @@ void CHIPWindowCoveringCurrentPositionLiftPercent100thsAttributeCallback::Callba
 }
 
 CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback::
-    CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPWindowCoveringClusterCurrentPositionTiltPercent100thsAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -27960,8 +27863,8 @@ CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback::
     }
 }
 
-CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback::
-    ~CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback()
+CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback::~
+CHIPWindowCoveringCurrentPositionTiltPercent100thsAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -28226,8 +28129,7 @@ void CHIPWindowCoveringEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPWindowCoveringAttributeListAttributeCallback::CHIPWindowCoveringAttributeListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPWindowCoveringClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPWindowCoveringClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -28512,8 +28414,7 @@ void CHIPBarrierControlEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPBarrierControlAttributeListAttributeCallback::CHIPBarrierControlAttributeListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPBarrierControlClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPBarrierControlClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -28805,8 +28706,8 @@ CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback::CHIPPumpConfig
     }
 }
 
-CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback::
-    ~CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback()
+CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback::~
+CHIPPumpConfigurationAndControlMinConstPressureAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -28874,8 +28775,8 @@ CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback::CHIPPumpConfig
     }
 }
 
-CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback::
-    ~CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback()
+CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback::~
+CHIPPumpConfigurationAndControlMaxConstPressureAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -29605,7 +29506,7 @@ void CHIPPumpConfigurationAndControlSpeedAttributeCallback::CallbackFn(void * co
 }
 
 CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback::
-    CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPumpConfigurationAndControlClusterLifetimeRunningHoursAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -29623,8 +29524,8 @@ CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback::
     }
 }
 
-CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback::
-    ~CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback()
+CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback::~
+CHIPPumpConfigurationAndControlLifetimeRunningHoursAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -29742,7 +29643,7 @@ void CHIPPumpConfigurationAndControlPowerAttributeCallback::CallbackFn(void * co
 }
 
 CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback::
-    CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPumpConfigurationAndControlClusterLifetimeEnergyConsumedAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -29760,8 +29661,8 @@ CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback::
     }
 }
 
-CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback::
-    ~CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback()
+CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback::~
+CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -29811,7 +29712,7 @@ void CHIPPumpConfigurationAndControlLifetimeEnergyConsumedAttributeCallback::Cal
 }
 
 CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback::
-    CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPumpConfigurationAndControlClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -29829,8 +29730,8 @@ CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback::
-    ~CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback()
+CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback::~
+CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -29884,7 +29785,7 @@ void CHIPPumpConfigurationAndControlGeneratedCommandListAttributeCallback::Callb
 }
 
 CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback::
-    CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPumpConfigurationAndControlClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -29902,8 +29803,8 @@ CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback::
-    ~CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback()
+CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback::~
+CHIPPumpConfigurationAndControlAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -30102,8 +30003,7 @@ void CHIPPumpConfigurationAndControlAttributeListAttributeCallback::CallbackFn(
 
 CHIPThermostatLocalTemperatureAttributeCallback::CHIPThermostatLocalTemperatureAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPThermostatClusterLocalTemperatureAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThermostatClusterLocalTemperatureAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -30170,8 +30070,7 @@ void CHIPThermostatLocalTemperatureAttributeCallback::CallbackFn(void * context,
 
 CHIPThermostatOutdoorTemperatureAttributeCallback::CHIPThermostatOutdoorTemperatureAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPThermostatClusterOutdoorTemperatureAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThermostatClusterOutdoorTemperatureAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -30306,8 +30205,7 @@ void CHIPThermostatTemperatureSetpointHoldDurationAttributeCallback::CallbackFn(
 
 CHIPThermostatSetpointChangeAmountAttributeCallback::CHIPThermostatSetpointChangeAmountAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPThermostatClusterSetpointChangeAmountAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThermostatClusterSetpointChangeAmountAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -30374,8 +30272,7 @@ void CHIPThermostatSetpointChangeAmountAttributeCallback::CallbackFn(void * cont
 
 CHIPThermostatOccupiedSetbackAttributeCallback::CHIPThermostatOccupiedSetbackAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPThermostatClusterOccupiedSetbackAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThermostatClusterOccupiedSetbackAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -30442,8 +30339,7 @@ void CHIPThermostatOccupiedSetbackAttributeCallback::CallbackFn(void * context,
 
 CHIPThermostatOccupiedSetbackMinAttributeCallback::CHIPThermostatOccupiedSetbackMinAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPThermostatClusterOccupiedSetbackMinAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThermostatClusterOccupiedSetbackMinAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -30510,8 +30406,7 @@ void CHIPThermostatOccupiedSetbackMinAttributeCallback::CallbackFn(void * contex
 
 CHIPThermostatOccupiedSetbackMaxAttributeCallback::CHIPThermostatOccupiedSetbackMaxAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPThermostatClusterOccupiedSetbackMaxAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThermostatClusterOccupiedSetbackMaxAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -30578,8 +30473,7 @@ void CHIPThermostatOccupiedSetbackMaxAttributeCallback::CallbackFn(void * contex
 
 CHIPThermostatUnoccupiedSetbackAttributeCallback::CHIPThermostatUnoccupiedSetbackAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPThermostatClusterUnoccupiedSetbackAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThermostatClusterUnoccupiedSetbackAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -30646,8 +30540,7 @@ void CHIPThermostatUnoccupiedSetbackAttributeCallback::CallbackFn(void * context
 
 CHIPThermostatUnoccupiedSetbackMinAttributeCallback::CHIPThermostatUnoccupiedSetbackMinAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPThermostatClusterUnoccupiedSetbackMinAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThermostatClusterUnoccupiedSetbackMinAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -30714,8 +30607,7 @@ void CHIPThermostatUnoccupiedSetbackMinAttributeCallback::CallbackFn(void * cont
 
 CHIPThermostatUnoccupiedSetbackMaxAttributeCallback::CHIPThermostatUnoccupiedSetbackMaxAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPThermostatClusterUnoccupiedSetbackMaxAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThermostatClusterUnoccupiedSetbackMaxAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -30782,8 +30674,7 @@ void CHIPThermostatUnoccupiedSetbackMaxAttributeCallback::CallbackFn(void * cont
 
 CHIPThermostatACCoilTemperatureAttributeCallback::CHIPThermostatACCoilTemperatureAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPThermostatClusterACCoilTemperatureAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThermostatClusterACCoilTemperatureAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -30850,8 +30741,7 @@ void CHIPThermostatACCoilTemperatureAttributeCallback::CallbackFn(void * context
 
 CHIPThermostatGeneratedCommandListAttributeCallback::CHIPThermostatGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPThermostatClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThermostatClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -30922,8 +30812,7 @@ void CHIPThermostatGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPThermostatAcceptedCommandListAttributeCallback::CHIPThermostatAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPThermostatClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPThermostatClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -31265,8 +31154,7 @@ void CHIPFanControlSpeedSettingAttributeCallback::CallbackFn(void * context, con
 
 CHIPFanControlGeneratedCommandListAttributeCallback::CHIPFanControlGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPFanControlClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPFanControlClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -31337,8 +31225,7 @@ void CHIPFanControlGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPFanControlAcceptedCommandListAttributeCallback::CHIPFanControlAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPFanControlClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPFanControlClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -31548,7 +31435,7 @@ void CHIPFanControlAttributeListAttributeCallback::CallbackFn(void * context,
 }
 
 CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback::
-    CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPThermostatUserInterfaceConfigurationClusterGeneratedCommandListAttributeCallbackType>(CallbackFn,
                                                                                                                        this),
     keepAlive(keepAlive)
@@ -31567,8 +31454,8 @@ CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback::
-    ~CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback()
+CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback::~
+CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -31623,7 +31510,7 @@ void CHIPThermostatUserInterfaceConfigurationGeneratedCommandListAttributeCallba
 }
 
 CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback::
-    CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPThermostatUserInterfaceConfigurationClusterAcceptedCommandListAttributeCallbackType>(CallbackFn,
                                                                                                                       this),
     keepAlive(keepAlive)
@@ -31642,8 +31529,8 @@ CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback::
-    ~CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback()
+CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback::~
+CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -31698,7 +31585,7 @@ void CHIPThermostatUserInterfaceConfigurationAcceptedCommandListAttributeCallbac
 }
 
 CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback::
-    CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPThermostatUserInterfaceConfigurationClusterEventListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -31716,8 +31603,8 @@ CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback::
     }
 }
 
-CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback::
-    ~CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback()
+CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback::~
+CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -31771,7 +31658,7 @@ void CHIPThermostatUserInterfaceConfigurationEventListAttributeCallback::Callbac
 }
 
 CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback::
-    CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -31789,8 +31676,8 @@ CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback::
     }
 }
 
-CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback::
-    ~CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback()
+CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback::~
+CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -31845,8 +31732,7 @@ void CHIPThermostatUserInterfaceConfigurationAttributeListAttributeCallback::Cal
 
 CHIPColorControlNumberOfPrimariesAttributeCallback::CHIPColorControlNumberOfPrimariesAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPColorControlClusterNumberOfPrimariesAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPColorControlClusterNumberOfPrimariesAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -31913,8 +31799,7 @@ void CHIPColorControlNumberOfPrimariesAttributeCallback::CallbackFn(void * conte
 
 CHIPColorControlPrimary1IntensityAttributeCallback::CHIPColorControlPrimary1IntensityAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPColorControlClusterPrimary1IntensityAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPColorControlClusterPrimary1IntensityAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -31981,8 +31866,7 @@ void CHIPColorControlPrimary1IntensityAttributeCallback::CallbackFn(void * conte
 
 CHIPColorControlPrimary2IntensityAttributeCallback::CHIPColorControlPrimary2IntensityAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPColorControlClusterPrimary2IntensityAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPColorControlClusterPrimary2IntensityAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -32049,8 +31933,7 @@ void CHIPColorControlPrimary2IntensityAttributeCallback::CallbackFn(void * conte
 
 CHIPColorControlPrimary3IntensityAttributeCallback::CHIPColorControlPrimary3IntensityAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPColorControlClusterPrimary3IntensityAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPColorControlClusterPrimary3IntensityAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -32117,8 +32000,7 @@ void CHIPColorControlPrimary3IntensityAttributeCallback::CallbackFn(void * conte
 
 CHIPColorControlPrimary4IntensityAttributeCallback::CHIPColorControlPrimary4IntensityAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPColorControlClusterPrimary4IntensityAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPColorControlClusterPrimary4IntensityAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -32185,8 +32067,7 @@ void CHIPColorControlPrimary4IntensityAttributeCallback::CallbackFn(void * conte
 
 CHIPColorControlPrimary5IntensityAttributeCallback::CHIPColorControlPrimary5IntensityAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPColorControlClusterPrimary5IntensityAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPColorControlClusterPrimary5IntensityAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -32253,8 +32134,7 @@ void CHIPColorControlPrimary5IntensityAttributeCallback::CallbackFn(void * conte
 
 CHIPColorControlPrimary6IntensityAttributeCallback::CHIPColorControlPrimary6IntensityAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPColorControlClusterPrimary6IntensityAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPColorControlClusterPrimary6IntensityAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -32807,8 +32687,7 @@ void CHIPColorControlEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPColorControlAttributeListAttributeCallback::CHIPColorControlAttributeListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPColorControlClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPColorControlClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -32964,8 +32843,8 @@ CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback::CHIPBallastCon
     }
 }
 
-CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback::
-    ~CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback()
+CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback::~
+CHIPBallastConfigurationBallastFactorAdjustmentAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -33364,8 +33243,7 @@ void CHIPBallastConfigurationAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPBallastConfigurationEventListAttributeCallback::CHIPBallastConfigurationEventListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPBallastConfigurationClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPBallastConfigurationClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -34764,8 +34642,7 @@ void CHIPPressureMeasurementMaxMeasuredValueAttributeCallback::CallbackFn(void *
 
 CHIPPressureMeasurementScaledValueAttributeCallback::CHIPPressureMeasurementScaledValueAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPPressureMeasurementClusterScaledValueAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPPressureMeasurementClusterScaledValueAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -35112,8 +34989,7 @@ void CHIPPressureMeasurementAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPPressureMeasurementEventListAttributeCallback::CHIPPressureMeasurementEventListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPPressureMeasurementClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPPressureMeasurementClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -35256,8 +35132,7 @@ void CHIPPressureMeasurementAttributeListAttributeCallback::CallbackFn(
 
 CHIPFlowMeasurementMeasuredValueAttributeCallback::CHIPFlowMeasurementMeasuredValueAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPFlowMeasurementClusterMeasuredValueAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPFlowMeasurementClusterMeasuredValueAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -35674,8 +35549,7 @@ void CHIPFlowMeasurementEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPFlowMeasurementAttributeListAttributeCallback::CHIPFlowMeasurementAttributeListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPFlowMeasurementClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPFlowMeasurementClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -35831,8 +35705,8 @@ CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback::CHIPRelativeHu
     }
 }
 
-CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback::
-    ~CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback()
+CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback::~
+CHIPRelativeHumidityMeasurementMinMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -35900,8 +35774,8 @@ CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback::CHIPRelativeHu
     }
 }
 
-CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback::
-    ~CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback()
+CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback::~
+CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -35951,7 +35825,7 @@ void CHIPRelativeHumidityMeasurementMaxMeasuredValueAttributeCallback::CallbackF
 }
 
 CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback::
-    CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRelativeHumidityMeasurementClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -35969,8 +35843,8 @@ CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback::
-    ~CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback()
+CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback::~
+CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -36024,7 +35898,7 @@ void CHIPRelativeHumidityMeasurementGeneratedCommandListAttributeCallback::Callb
 }
 
 CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback::
-    CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRelativeHumidityMeasurementClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -36042,8 +35916,8 @@ CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback::
-    ~CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback()
+CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback::~
+CHIPRelativeHumidityMeasurementAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -36386,8 +36260,7 @@ void CHIPOccupancySensingAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPOccupancySensingEventListAttributeCallback::CHIPOccupancySensingEventListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPOccupancySensingClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPOccupancySensingClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -36458,8 +36331,7 @@ void CHIPOccupancySensingEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPOccupancySensingAttributeListAttributeCallback::CHIPOccupancySensingAttributeListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPOccupancySensingClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPOccupancySensingClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -36529,7 +36401,7 @@ void CHIPOccupancySensingAttributeListAttributeCallback::CallbackFn(
 }
 
 CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback::
-    CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonMonoxideConcentrationMeasurementClusterMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -36547,8 +36419,8 @@ CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback::
     }
 }
 
-CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback::
-    ~CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback()
+CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback::~
+CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -36598,7 +36470,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementMeasuredValueAttributeCallback::C
 }
 
 CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonMonoxideConcentrationMeasurementClusterMinMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                      this),
     keepAlive(keepAlive)
@@ -36617,8 +36489,8 @@ CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback::
     }
 }
 
-CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    ~CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback()
+CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback::~
+CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -36669,7 +36541,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementMinMeasuredValueAttributeCallback
 }
 
 CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonMonoxideConcentrationMeasurementClusterMaxMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                      this),
     keepAlive(keepAlive)
@@ -36688,8 +36560,8 @@ CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::
     }
 }
 
-CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    ~CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback()
+CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::~
+CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -36740,7 +36612,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementMaxMeasuredValueAttributeCallback
 }
 
 CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonMonoxideConcentrationMeasurementClusterPeakMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                       this),
     keepAlive(keepAlive)
@@ -36759,8 +36631,8 @@ CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::
     }
 }
 
-CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    ~CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback()
+CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::~
+CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -36811,7 +36683,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementPeakMeasuredValueAttributeCallbac
 }
 
 CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonMonoxideConcentrationMeasurementClusterAverageMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                          this),
     keepAlive(keepAlive)
@@ -36830,8 +36702,8 @@ CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback:
     }
 }
 
-CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    ~CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback()
+CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::~
+CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -36882,7 +36754,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementAverageMeasuredValueAttributeCall
 }
 
 CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonMonoxideConcentrationMeasurementClusterGeneratedCommandListAttributeCallbackType>(CallbackFn,
                                                                                                                          this),
     keepAlive(keepAlive)
@@ -36901,8 +36773,8 @@ CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback:
     }
 }
 
-CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    ~CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback()
+CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback::~
+CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -36957,7 +36829,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementGeneratedCommandListAttributeCall
 }
 
 CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonMonoxideConcentrationMeasurementClusterAcceptedCommandListAttributeCallbackType>(CallbackFn,
                                                                                                                         this),
     keepAlive(keepAlive)
@@ -36976,8 +36848,8 @@ CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    ~CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback()
+CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback::~
+CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37032,7 +36904,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementAcceptedCommandListAttributeCallb
 }
 
 CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback::
-    CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonMonoxideConcentrationMeasurementClusterEventListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -37050,8 +36922,8 @@ CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback::
     }
 }
 
-CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback::
-    ~CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback()
+CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback::~
+CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37105,7 +36977,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementEventListAttributeCallback::Callb
 }
 
 CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback::
-    CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonMonoxideConcentrationMeasurementClusterAttributeListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -37123,8 +36995,8 @@ CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback::
     }
 }
 
-CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback::
-    ~CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback()
+CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback::~
+CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37178,7 +37050,7 @@ void CHIPCarbonMonoxideConcentrationMeasurementAttributeListAttributeCallback::C
 }
 
 CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback::
-    CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonDioxideConcentrationMeasurementClusterMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -37196,8 +37068,8 @@ CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback::
     }
 }
 
-CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback::
-    ~CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback()
+CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback::~
+CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37247,7 +37119,7 @@ void CHIPCarbonDioxideConcentrationMeasurementMeasuredValueAttributeCallback::Ca
 }
 
 CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonDioxideConcentrationMeasurementClusterMinMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                     this),
     keepAlive(keepAlive)
@@ -37266,8 +37138,8 @@ CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback::
     }
 }
 
-CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    ~CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback()
+CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback::~
+CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37318,7 +37190,7 @@ void CHIPCarbonDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback:
 }
 
 CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonDioxideConcentrationMeasurementClusterMaxMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                     this),
     keepAlive(keepAlive)
@@ -37337,8 +37209,8 @@ CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::
     }
 }
 
-CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    ~CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback()
+CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::~
+CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37389,7 +37261,7 @@ void CHIPCarbonDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback:
 }
 
 CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonDioxideConcentrationMeasurementClusterPeakMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                      this),
     keepAlive(keepAlive)
@@ -37408,8 +37280,8 @@ CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::
     }
 }
 
-CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    ~CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback()
+CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::~
+CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37460,7 +37332,7 @@ void CHIPCarbonDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback
 }
 
 CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonDioxideConcentrationMeasurementClusterAverageMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                         this),
     keepAlive(keepAlive)
@@ -37479,8 +37351,8 @@ CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::
     }
 }
 
-CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    ~CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback()
+CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::~
+CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37531,7 +37403,7 @@ void CHIPCarbonDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallb
 }
 
 CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonDioxideConcentrationMeasurementClusterGeneratedCommandListAttributeCallbackType>(CallbackFn,
                                                                                                                         this),
     keepAlive(keepAlive)
@@ -37550,8 +37422,8 @@ CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    ~CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback()
+CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback::~
+CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37606,7 +37478,7 @@ void CHIPCarbonDioxideConcentrationMeasurementGeneratedCommandListAttributeCallb
 }
 
 CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonDioxideConcentrationMeasurementClusterAcceptedCommandListAttributeCallbackType>(CallbackFn,
                                                                                                                        this),
     keepAlive(keepAlive)
@@ -37625,8 +37497,8 @@ CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    ~CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback()
+CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback::~
+CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37681,7 +37553,7 @@ void CHIPCarbonDioxideConcentrationMeasurementAcceptedCommandListAttributeCallba
 }
 
 CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback::
-    CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonDioxideConcentrationMeasurementClusterEventListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -37699,8 +37571,8 @@ CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback::
     }
 }
 
-CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback::
-    ~CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback()
+CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback::~
+CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37754,7 +37626,7 @@ void CHIPCarbonDioxideConcentrationMeasurementEventListAttributeCallback::Callba
 }
 
 CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback::
-    CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPCarbonDioxideConcentrationMeasurementClusterAttributeListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -37772,8 +37644,8 @@ CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback::
     }
 }
 
-CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback::
-    ~CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback()
+CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback::~
+CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37827,7 +37699,7 @@ void CHIPCarbonDioxideConcentrationMeasurementAttributeListAttributeCallback::Ca
 }
 
 CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback::
-    CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPNitrogenDioxideConcentrationMeasurementClusterMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                    this),
     keepAlive(keepAlive)
@@ -37846,8 +37718,8 @@ CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback::
     }
 }
 
-CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback::
-    ~CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback()
+CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback::~
+CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37897,7 +37769,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementMeasuredValueAttributeCallback::
 }
 
 CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPNitrogenDioxideConcentrationMeasurementClusterMinMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                       this),
     keepAlive(keepAlive)
@@ -37916,8 +37788,8 @@ CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback::
     }
 }
 
-CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    ~CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback()
+CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback::~
+CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -37968,7 +37840,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementMinMeasuredValueAttributeCallbac
 }
 
 CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPNitrogenDioxideConcentrationMeasurementClusterMaxMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                       this),
     keepAlive(keepAlive)
@@ -37987,8 +37859,8 @@ CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::
     }
 }
 
-CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    ~CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback()
+CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback::~
+CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -38039,7 +37911,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementMaxMeasuredValueAttributeCallbac
 }
 
 CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPNitrogenDioxideConcentrationMeasurementClusterPeakMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                        this),
     keepAlive(keepAlive)
@@ -38058,8 +37930,8 @@ CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::
     }
 }
 
-CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    ~CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback()
+CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback::~
+CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -38110,7 +37982,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementPeakMeasuredValueAttributeCallba
 }
 
 CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPNitrogenDioxideConcentrationMeasurementClusterAverageMeasuredValueAttributeCallbackType>(
         CallbackFn, this),
     keepAlive(keepAlive)
@@ -38129,8 +38001,8 @@ CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback
     }
 }
 
-CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    ~CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback()
+CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback::~
+CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -38181,7 +38053,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementAverageMeasuredValueAttributeCal
 }
 
 CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPNitrogenDioxideConcentrationMeasurementClusterGeneratedCommandListAttributeCallbackType>(
         CallbackFn, this),
     keepAlive(keepAlive)
@@ -38200,8 +38072,8 @@ CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback
     }
 }
 
-CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    ~CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback()
+CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback::~
+CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -38256,7 +38128,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementGeneratedCommandListAttributeCal
 }
 
 CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPNitrogenDioxideConcentrationMeasurementClusterAcceptedCommandListAttributeCallbackType>(CallbackFn,
                                                                                                                          this),
     keepAlive(keepAlive)
@@ -38275,8 +38147,8 @@ CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback:
     }
 }
 
-CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    ~CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback()
+CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback::~
+CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -38331,7 +38203,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementAcceptedCommandListAttributeCall
 }
 
 CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback::
-    CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPNitrogenDioxideConcentrationMeasurementClusterEventListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -38349,8 +38221,8 @@ CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback::
     }
 }
 
-CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback::
-    ~CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback()
+CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback::~
+CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -38404,7 +38276,7 @@ void CHIPNitrogenDioxideConcentrationMeasurementEventListAttributeCallback::Call
 }
 
 CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback::
-    CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPNitrogenDioxideConcentrationMeasurementClusterAttributeListAttributeCallbackType>(CallbackFn,
                                                                                                                    this),
     keepAlive(keepAlive)
@@ -38423,8 +38295,8 @@ CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback::
     }
 }
 
-CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback::
-    ~CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback()
+CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback::~
+CHIPNitrogenDioxideConcentrationMeasurementAttributeListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -38546,7 +38418,7 @@ void CHIPOzoneConcentrationMeasurementMeasuredValueAttributeCallback::CallbackFn
 }
 
 CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOzoneConcentrationMeasurementClusterMinMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -38564,8 +38436,8 @@ CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback::
     }
 }
 
-CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    ~CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback()
+CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback::~
+CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -38615,7 +38487,7 @@ void CHIPOzoneConcentrationMeasurementMinMeasuredValueAttributeCallback::Callbac
 }
 
 CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOzoneConcentrationMeasurementClusterMaxMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -38633,8 +38505,8 @@ CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback::
     }
 }
 
-CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    ~CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback()
+CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback::~
+CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -38684,7 +38556,7 @@ void CHIPOzoneConcentrationMeasurementMaxMeasuredValueAttributeCallback::Callbac
 }
 
 CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOzoneConcentrationMeasurementClusterPeakMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -38702,8 +38574,8 @@ CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback::
     }
 }
 
-CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    ~CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback()
+CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback::~
+CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -38753,7 +38625,7 @@ void CHIPOzoneConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callba
 }
 
 CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOzoneConcentrationMeasurementClusterAverageMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -38771,8 +38643,8 @@ CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback::
     }
 }
 
-CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    ~CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback()
+CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback::~
+CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -38822,7 +38694,7 @@ void CHIPOzoneConcentrationMeasurementAverageMeasuredValueAttributeCallback::Cal
 }
 
 CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOzoneConcentrationMeasurementClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -38840,8 +38712,8 @@ CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    ~CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback()
+CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback::~
+CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -38895,7 +38767,7 @@ void CHIPOzoneConcentrationMeasurementGeneratedCommandListAttributeCallback::Cal
 }
 
 CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPOzoneConcentrationMeasurementClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -38913,8 +38785,8 @@ CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    ~CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback()
+CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback::~
+CHIPOzoneConcentrationMeasurementAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -39180,7 +39052,7 @@ void CHIPPm25ConcentrationMeasurementMeasuredValueAttributeCallback::CallbackFn(
 }
 
 CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm25ConcentrationMeasurementClusterMinMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -39198,8 +39070,8 @@ CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback::
     }
 }
 
-CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    ~CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback()
+CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback::~
+CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -39249,7 +39121,7 @@ void CHIPPm25ConcentrationMeasurementMinMeasuredValueAttributeCallback::Callback
 }
 
 CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm25ConcentrationMeasurementClusterMaxMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -39267,8 +39139,8 @@ CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback::
     }
 }
 
-CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    ~CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback()
+CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback::~
+CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -39318,7 +39190,7 @@ void CHIPPm25ConcentrationMeasurementMaxMeasuredValueAttributeCallback::Callback
 }
 
 CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm25ConcentrationMeasurementClusterPeakMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -39336,8 +39208,8 @@ CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback::
     }
 }
 
-CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    ~CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback()
+CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback::~
+CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -39387,7 +39259,7 @@ void CHIPPm25ConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callbac
 }
 
 CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm25ConcentrationMeasurementClusterAverageMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -39405,8 +39277,8 @@ CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback::
     }
 }
 
-CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    ~CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback()
+CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback::~
+CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -39456,7 +39328,7 @@ void CHIPPm25ConcentrationMeasurementAverageMeasuredValueAttributeCallback::Call
 }
 
 CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm25ConcentrationMeasurementClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -39474,8 +39346,8 @@ CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    ~CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback()
+CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback::~
+CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -39529,7 +39401,7 @@ void CHIPPm25ConcentrationMeasurementGeneratedCommandListAttributeCallback::Call
 }
 
 CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm25ConcentrationMeasurementClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -39547,8 +39419,8 @@ CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    ~CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback()
+CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback::~
+CHIPPm25ConcentrationMeasurementAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -39746,7 +39618,7 @@ void CHIPPm25ConcentrationMeasurementAttributeListAttributeCallback::CallbackFn(
 }
 
 CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback::
-    CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPFormaldehydeConcentrationMeasurementClusterMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -39764,8 +39636,8 @@ CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback::
     }
 }
 
-CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback::
-    ~CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback()
+CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback::~
+CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -39815,7 +39687,7 @@ void CHIPFormaldehydeConcentrationMeasurementMeasuredValueAttributeCallback::Cal
 }
 
 CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPFormaldehydeConcentrationMeasurementClusterMinMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                    this),
     keepAlive(keepAlive)
@@ -39834,8 +39706,8 @@ CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback::
     }
 }
 
-CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    ~CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback()
+CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback::~
+CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -39885,7 +39757,7 @@ void CHIPFormaldehydeConcentrationMeasurementMinMeasuredValueAttributeCallback::
 }
 
 CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPFormaldehydeConcentrationMeasurementClusterMaxMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                    this),
     keepAlive(keepAlive)
@@ -39904,8 +39776,8 @@ CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback::
     }
 }
 
-CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    ~CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback()
+CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback::~
+CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -39955,7 +39827,7 @@ void CHIPFormaldehydeConcentrationMeasurementMaxMeasuredValueAttributeCallback::
 }
 
 CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPFormaldehydeConcentrationMeasurementClusterPeakMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                     this),
     keepAlive(keepAlive)
@@ -39974,8 +39846,8 @@ CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback::
     }
 }
 
-CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    ~CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback()
+CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback::~
+CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -40026,7 +39898,7 @@ void CHIPFormaldehydeConcentrationMeasurementPeakMeasuredValueAttributeCallback:
 }
 
 CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPFormaldehydeConcentrationMeasurementClusterAverageMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                        this),
     keepAlive(keepAlive)
@@ -40045,8 +39917,8 @@ CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback::
     }
 }
 
-CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    ~CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback()
+CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback::~
+CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -40097,7 +39969,7 @@ void CHIPFormaldehydeConcentrationMeasurementAverageMeasuredValueAttributeCallba
 }
 
 CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPFormaldehydeConcentrationMeasurementClusterGeneratedCommandListAttributeCallbackType>(CallbackFn,
                                                                                                                        this),
     keepAlive(keepAlive)
@@ -40116,8 +39988,8 @@ CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    ~CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback()
+CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback::~
+CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -40172,7 +40044,7 @@ void CHIPFormaldehydeConcentrationMeasurementGeneratedCommandListAttributeCallba
 }
 
 CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPFormaldehydeConcentrationMeasurementClusterAcceptedCommandListAttributeCallbackType>(CallbackFn,
                                                                                                                       this),
     keepAlive(keepAlive)
@@ -40191,8 +40063,8 @@ CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    ~CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback()
+CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback::~
+CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -40247,7 +40119,7 @@ void CHIPFormaldehydeConcentrationMeasurementAcceptedCommandListAttributeCallbac
 }
 
 CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback::
-    CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPFormaldehydeConcentrationMeasurementClusterEventListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -40265,8 +40137,8 @@ CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback::
     }
 }
 
-CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback::
-    ~CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback()
+CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback::~
+CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -40320,7 +40192,7 @@ void CHIPFormaldehydeConcentrationMeasurementEventListAttributeCallback::Callbac
 }
 
 CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback::
-    CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPFormaldehydeConcentrationMeasurementClusterAttributeListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -40338,8 +40210,8 @@ CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback::
     }
 }
 
-CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback::
-    ~CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback()
+CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback::~
+CHIPFormaldehydeConcentrationMeasurementAttributeListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -40479,8 +40351,8 @@ CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback::CHIPPm1Concent
     }
 }
 
-CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    ~CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback()
+CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback::~
+CHIPPm1ConcentrationMeasurementMinMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -40548,8 +40420,8 @@ CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback::CHIPPm1Concent
     }
 }
 
-CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    ~CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback()
+CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback::~
+CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -40599,7 +40471,7 @@ void CHIPPm1ConcentrationMeasurementMaxMeasuredValueAttributeCallback::CallbackF
 }
 
 CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm1ConcentrationMeasurementClusterPeakMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -40617,8 +40489,8 @@ CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback::
     }
 }
 
-CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    ~CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback()
+CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback::~
+CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -40668,7 +40540,7 @@ void CHIPPm1ConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callback
 }
 
 CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm1ConcentrationMeasurementClusterAverageMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -40686,8 +40558,8 @@ CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback::
     }
 }
 
-CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    ~CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback()
+CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback::~
+CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -40737,7 +40609,7 @@ void CHIPPm1ConcentrationMeasurementAverageMeasuredValueAttributeCallback::Callb
 }
 
 CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm1ConcentrationMeasurementClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -40755,8 +40627,8 @@ CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    ~CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback()
+CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback::~
+CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -40810,7 +40682,7 @@ void CHIPPm1ConcentrationMeasurementGeneratedCommandListAttributeCallback::Callb
 }
 
 CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm1ConcentrationMeasurementClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -40828,8 +40700,8 @@ CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    ~CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback()
+CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback::~
+CHIPPm1ConcentrationMeasurementAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -41095,7 +40967,7 @@ void CHIPPm10ConcentrationMeasurementMeasuredValueAttributeCallback::CallbackFn(
 }
 
 CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm10ConcentrationMeasurementClusterMinMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -41113,8 +40985,8 @@ CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback::
     }
 }
 
-CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    ~CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback()
+CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback::~
+CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -41164,7 +41036,7 @@ void CHIPPm10ConcentrationMeasurementMinMeasuredValueAttributeCallback::Callback
 }
 
 CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm10ConcentrationMeasurementClusterMaxMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -41182,8 +41054,8 @@ CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback::
     }
 }
 
-CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    ~CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback()
+CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback::~
+CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -41233,7 +41105,7 @@ void CHIPPm10ConcentrationMeasurementMaxMeasuredValueAttributeCallback::Callback
 }
 
 CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm10ConcentrationMeasurementClusterPeakMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -41251,8 +41123,8 @@ CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback::
     }
 }
 
-CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    ~CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback()
+CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback::~
+CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -41302,7 +41174,7 @@ void CHIPPm10ConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callbac
 }
 
 CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm10ConcentrationMeasurementClusterAverageMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -41320,8 +41192,8 @@ CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback::
     }
 }
 
-CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    ~CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback()
+CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback::~
+CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -41371,7 +41243,7 @@ void CHIPPm10ConcentrationMeasurementAverageMeasuredValueAttributeCallback::Call
 }
 
 CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm10ConcentrationMeasurementClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -41389,8 +41261,8 @@ CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    ~CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback()
+CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback::~
+CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -41444,7 +41316,7 @@ void CHIPPm10ConcentrationMeasurementGeneratedCommandListAttributeCallback::Call
 }
 
 CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPPm10ConcentrationMeasurementClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -41462,8 +41334,8 @@ CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    ~CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback()
+CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback::~
+CHIPPm10ConcentrationMeasurementAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -41661,7 +41533,7 @@ void CHIPPm10ConcentrationMeasurementAttributeListAttributeCallback::CallbackFn(
 }
 
 CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback::
-    CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterMeasuredValueAttributeCallbackType>(
         CallbackFn, this),
     keepAlive(keepAlive)
@@ -41680,8 +41552,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeC
     }
 }
 
-CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback::
-    ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback()
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback::~
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -41734,8 +41606,7 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMeasuredValueAttri
 }
 
 CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback,
-                                                                                               bool keepAlive) :
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterMinMeasuredValueAttributeCallbackType>(
         CallbackFn, this),
     keepAlive(keepAlive)
@@ -41754,8 +41625,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttribu
     }
 }
 
-CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback()
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback::~
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -41808,8 +41679,7 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMinMeasuredValueAt
 }
 
 CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback,
-                                                                                               bool keepAlive) :
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterMaxMeasuredValueAttributeCallbackType>(
         CallbackFn, this),
     keepAlive(keepAlive)
@@ -41828,8 +41698,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttribu
     }
 }
 
-CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback()
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback::~
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -41882,8 +41752,7 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementMaxMeasuredValueAt
 }
 
 CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback,
-                                                                                                bool keepAlive) :
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<
         CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterPeakMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
@@ -41902,8 +41771,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttrib
     }
 }
 
-CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback()
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback::~
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -41956,8 +41825,8 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementPeakMeasuredValueA
 }
 
 CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback,
-                                                                                                   bool keepAlive) :
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback,
+                                                                                               bool keepAlive) :
     chip::Callback::Callback<
         CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterAverageMeasuredValueAttributeCallbackType>(CallbackFn,
                                                                                                                    this),
@@ -41977,8 +41846,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAtt
     }
 }
 
-CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback()
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback::~
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -42032,8 +41901,8 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAverageMeasuredVal
 }
 
 CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback,
-                                                                                                   bool keepAlive) :
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback,
+                                                                                               bool keepAlive) :
     chip::Callback::Callback<
         CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterGeneratedCommandListAttributeCallbackType>(CallbackFn,
                                                                                                                    this),
@@ -42053,8 +41922,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAtt
     }
 }
 
-CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback()
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback::~
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -42112,8 +41981,8 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementGeneratedCommandLi
 }
 
 CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback,
-                                                                                                  bool keepAlive) :
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback,
+                                                                                              bool keepAlive) :
     chip::Callback::Callback<
         CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
@@ -42132,8 +42001,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttr
     }
 }
 
-CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback()
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback::~
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -42191,7 +42060,7 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAcceptedCommandLis
 }
 
 CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback::
-    CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterEventListAttributeCallbackType>(
         CallbackFn, this),
     keepAlive(keepAlive)
@@ -42210,8 +42079,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallb
     }
 }
 
-CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback::
-    ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback()
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback::~
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -42267,7 +42136,7 @@ void CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementEventListAttribute
 }
 
 CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback::
-    CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementClusterAttributeListAttributeCallbackType>(
         CallbackFn, this),
     keepAlive(keepAlive)
@@ -42286,8 +42155,8 @@ CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeC
     }
 }
 
-CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback::
-    ~CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback()
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback::~
+CHIPTotalVolatileOrganicCompoundsConcentrationMeasurementAttributeListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -42412,7 +42281,7 @@ void CHIPRadonConcentrationMeasurementMeasuredValueAttributeCallback::CallbackFn
 }
 
 CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRadonConcentrationMeasurementClusterMinMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -42430,8 +42299,8 @@ CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback::
     }
 }
 
-CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback::
-    ~CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback()
+CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback::~
+CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -42481,7 +42350,7 @@ void CHIPRadonConcentrationMeasurementMinMeasuredValueAttributeCallback::Callbac
 }
 
 CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRadonConcentrationMeasurementClusterMaxMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -42499,8 +42368,8 @@ CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback::
     }
 }
 
-CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback::
-    ~CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback()
+CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback::~
+CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -42550,7 +42419,7 @@ void CHIPRadonConcentrationMeasurementMaxMeasuredValueAttributeCallback::Callbac
 }
 
 CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRadonConcentrationMeasurementClusterPeakMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -42568,8 +42437,8 @@ CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback::
     }
 }
 
-CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback::
-    ~CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback()
+CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback::~
+CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -42619,7 +42488,7 @@ void CHIPRadonConcentrationMeasurementPeakMeasuredValueAttributeCallback::Callba
 }
 
 CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRadonConcentrationMeasurementClusterAverageMeasuredValueAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -42637,8 +42506,8 @@ CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback::
     }
 }
 
-CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback::
-    ~CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback()
+CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback::~
+CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -42688,7 +42557,7 @@ void CHIPRadonConcentrationMeasurementAverageMeasuredValueAttributeCallback::Cal
 }
 
 CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRadonConcentrationMeasurementClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -42706,8 +42575,8 @@ CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback::
     }
 }
 
-CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback::
-    ~CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback()
+CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback::~
+CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -42761,7 +42630,7 @@ void CHIPRadonConcentrationMeasurementGeneratedCommandListAttributeCallback::Cal
 }
 
 CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
+CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) :
     chip::Callback::Callback<CHIPRadonConcentrationMeasurementClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
     keepAlive(keepAlive)
 {
@@ -42779,8 +42648,8 @@ CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback::
     }
 }
 
-CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback::
-    ~CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback()
+CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback::~
+CHIPRadonConcentrationMeasurementAcceptedCommandListAttributeCallback()
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -42979,8 +42848,7 @@ void CHIPRadonConcentrationMeasurementAttributeListAttributeCallback::CallbackFn
 
 CHIPWakeOnLanGeneratedCommandListAttributeCallback::CHIPWakeOnLanGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPWakeOnLanClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPWakeOnLanClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -43051,8 +42919,7 @@ void CHIPWakeOnLanGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPWakeOnLanAcceptedCommandListAttributeCallback::CHIPWakeOnLanAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPWakeOnLanClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPWakeOnLanClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -43401,8 +43268,7 @@ void CHIPChannelChannelListAttributeCallback::CallbackFn(
 
 CHIPChannelGeneratedCommandListAttributeCallback::CHIPChannelGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPChannelClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPChannelClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -43473,8 +43339,7 @@ void CHIPChannelGeneratedCommandListAttributeCallback::CallbackFn(void * context
 
 CHIPChannelAcceptedCommandListAttributeCallback::CHIPChannelAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPChannelClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPChannelClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -43685,8 +43550,7 @@ void CHIPChannelAttributeListAttributeCallback::CallbackFn(void * context,
 
 CHIPTargetNavigatorTargetListAttributeCallback::CHIPTargetNavigatorTargetListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPTargetNavigatorClusterTargetListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPTargetNavigatorClusterTargetListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -43996,8 +43860,7 @@ void CHIPTargetNavigatorEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPTargetNavigatorAttributeListAttributeCallback::CHIPTargetNavigatorAttributeListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPTargetNavigatorClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPTargetNavigatorClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -44198,8 +44061,7 @@ void CHIPMediaPlaybackDurationAttributeCallback::CallbackFn(void * context, cons
 
 CHIPMediaPlaybackSeekRangeEndAttributeCallback::CHIPMediaPlaybackSeekRangeEndAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPMediaPlaybackClusterSeekRangeEndAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPMediaPlaybackClusterSeekRangeEndAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -44266,8 +44128,7 @@ void CHIPMediaPlaybackSeekRangeEndAttributeCallback::CallbackFn(void * context,
 
 CHIPMediaPlaybackSeekRangeStartAttributeCallback::CHIPMediaPlaybackSeekRangeStartAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPMediaPlaybackClusterSeekRangeStartAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPMediaPlaybackClusterSeekRangeStartAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -44548,8 +44409,7 @@ void CHIPMediaPlaybackEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPMediaPlaybackAttributeListAttributeCallback::CHIPMediaPlaybackAttributeListAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPMediaPlaybackClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPMediaPlaybackClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -44724,8 +44584,7 @@ void CHIPMediaInputInputListAttributeCallback::CallbackFn(
 
 CHIPMediaInputGeneratedCommandListAttributeCallback::CHIPMediaInputGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPMediaInputClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPMediaInputClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -44796,8 +44655,7 @@ void CHIPMediaInputGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPMediaInputAcceptedCommandListAttributeCallback::CHIPMediaInputAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPMediaInputClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPMediaInputClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -45008,8 +44866,7 @@ void CHIPMediaInputAttributeListAttributeCallback::CallbackFn(void * context,
 
 CHIPLowPowerGeneratedCommandListAttributeCallback::CHIPLowPowerGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPLowPowerClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPLowPowerClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -45080,8 +44937,7 @@ void CHIPLowPowerGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPLowPowerAcceptedCommandListAttributeCallback::CHIPLowPowerAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPLowPowerClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPLowPowerClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -45364,8 +45220,7 @@ void CHIPKeypadInputGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPKeypadInputAcceptedCommandListAttributeCallback::CHIPKeypadInputAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPKeypadInputClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPKeypadInputClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -45576,8 +45431,7 @@ void CHIPKeypadInputAttributeListAttributeCallback::CallbackFn(void * context,
 
 CHIPContentLauncherAcceptHeaderAttributeCallback::CHIPContentLauncherAcceptHeaderAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPContentLauncherClusterAcceptHeaderAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPContentLauncherClusterAcceptHeaderAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -45858,8 +45712,7 @@ void CHIPContentLauncherEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPContentLauncherAttributeListAttributeCallback::CHIPContentLauncherAttributeListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPContentLauncherClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPContentLauncherClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -46103,8 +45956,7 @@ void CHIPAudioOutputGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPAudioOutputAcceptedCommandListAttributeCallback::CHIPAudioOutputAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPAudioOutputClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPAudioOutputClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -46315,8 +46167,7 @@ void CHIPAudioOutputAttributeListAttributeCallback::CallbackFn(void * context,
 
 CHIPApplicationLauncherCatalogListAttributeCallback::CHIPApplicationLauncherCatalogListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPApplicationLauncherClusterCatalogListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPApplicationLauncherClusterCatalogListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -46531,8 +46382,7 @@ void CHIPApplicationLauncherAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPApplicationLauncherEventListAttributeCallback::CHIPApplicationLauncherEventListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPApplicationLauncherClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPApplicationLauncherClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -46891,8 +46741,7 @@ void CHIPApplicationBasicAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPApplicationBasicEventListAttributeCallback::CHIPApplicationBasicEventListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPApplicationBasicClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPApplicationBasicClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -46963,8 +46812,7 @@ void CHIPApplicationBasicEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPApplicationBasicAttributeListAttributeCallback::CHIPApplicationBasicAttributeListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPApplicationBasicClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPApplicationBasicClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -47249,8 +47097,7 @@ void CHIPAccountLoginEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPAccountLoginAttributeListAttributeCallback::CHIPAccountLoginAttributeListAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPAccountLoginClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPAccountLoginClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -47465,8 +47312,7 @@ void CHIPElectricalMeasurementAcceptedCommandListAttributeCallback::CallbackFn(
 
 CHIPElectricalMeasurementEventListAttributeCallback::CHIPElectricalMeasurementEventListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPElectricalMeasurementClusterEventListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPElectricalMeasurementClusterEventListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -47679,8 +47525,7 @@ void CHIPUnitTestingListInt8uAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingListOctetStringAttributeCallback::CHIPUnitTestingListOctetStringAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterListOctetStringAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterListOctetStringAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -48406,8 +48251,7 @@ void CHIPUnitTestingListNullablesAndOptionalsStructAttributeCallback::CallbackFn
 
 CHIPUnitTestingListLongOctetStringAttributeCallback::CHIPUnitTestingListLongOctetStringAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterListLongOctetStringAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterListLongOctetStringAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -48477,8 +48321,7 @@ void CHIPUnitTestingListLongOctetStringAttributeCallback::CallbackFn(
 
 CHIPUnitTestingListFabricScopedAttributeCallback::CHIPUnitTestingListFabricScopedAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterListFabricScopedAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterListFabricScopedAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -48740,8 +48583,7 @@ void CHIPUnitTestingListFabricScopedAttributeCallback::CallbackFn(
 
 CHIPUnitTestingNullableBooleanAttributeCallback::CHIPUnitTestingNullableBooleanAttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableBooleanAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableBooleanAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -48807,8 +48649,7 @@ void CHIPUnitTestingNullableBooleanAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableBitmap8AttributeCallback::CHIPUnitTestingNullableBitmap8AttributeCallback(jobject javaCallback,
                                                                                                  bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableBitmap8AttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableBitmap8AttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -48875,8 +48716,7 @@ void CHIPUnitTestingNullableBitmap8AttributeCallback::CallbackFn(
 
 CHIPUnitTestingNullableBitmap16AttributeCallback::CHIPUnitTestingNullableBitmap16AttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableBitmap16AttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableBitmap16AttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -48943,8 +48783,7 @@ void CHIPUnitTestingNullableBitmap16AttributeCallback::CallbackFn(
 
 CHIPUnitTestingNullableBitmap32AttributeCallback::CHIPUnitTestingNullableBitmap32AttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableBitmap32AttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableBitmap32AttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -49011,8 +48850,7 @@ void CHIPUnitTestingNullableBitmap32AttributeCallback::CallbackFn(
 
 CHIPUnitTestingNullableBitmap64AttributeCallback::CHIPUnitTestingNullableBitmap64AttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableBitmap64AttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableBitmap64AttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -49145,8 +48983,7 @@ void CHIPUnitTestingNullableInt8uAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableInt16uAttributeCallback::CHIPUnitTestingNullableInt16uAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt16uAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt16uAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -49213,8 +49050,7 @@ void CHIPUnitTestingNullableInt16uAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableInt24uAttributeCallback::CHIPUnitTestingNullableInt24uAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt24uAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt24uAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -49281,8 +49117,7 @@ void CHIPUnitTestingNullableInt24uAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableInt32uAttributeCallback::CHIPUnitTestingNullableInt32uAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt32uAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt32uAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -49349,8 +49184,7 @@ void CHIPUnitTestingNullableInt32uAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableInt40uAttributeCallback::CHIPUnitTestingNullableInt40uAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt40uAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt40uAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -49417,8 +49251,7 @@ void CHIPUnitTestingNullableInt40uAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableInt48uAttributeCallback::CHIPUnitTestingNullableInt48uAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt48uAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt48uAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -49485,8 +49318,7 @@ void CHIPUnitTestingNullableInt48uAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableInt56uAttributeCallback::CHIPUnitTestingNullableInt56uAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt56uAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt56uAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -49553,8 +49385,7 @@ void CHIPUnitTestingNullableInt56uAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableInt64uAttributeCallback::CHIPUnitTestingNullableInt64uAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt64uAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt64uAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -49686,8 +49517,7 @@ void CHIPUnitTestingNullableInt8sAttributeCallback::CallbackFn(void * context, c
 
 CHIPUnitTestingNullableInt16sAttributeCallback::CHIPUnitTestingNullableInt16sAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt16sAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt16sAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -49754,8 +49584,7 @@ void CHIPUnitTestingNullableInt16sAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableInt24sAttributeCallback::CHIPUnitTestingNullableInt24sAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt24sAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt24sAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -49822,8 +49651,7 @@ void CHIPUnitTestingNullableInt24sAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableInt32sAttributeCallback::CHIPUnitTestingNullableInt32sAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt32sAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt32sAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -49890,8 +49718,7 @@ void CHIPUnitTestingNullableInt32sAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableInt40sAttributeCallback::CHIPUnitTestingNullableInt40sAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt40sAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt40sAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -49958,8 +49785,7 @@ void CHIPUnitTestingNullableInt40sAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableInt48sAttributeCallback::CHIPUnitTestingNullableInt48sAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt48sAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt48sAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -50026,8 +49852,7 @@ void CHIPUnitTestingNullableInt48sAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableInt56sAttributeCallback::CHIPUnitTestingNullableInt56sAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt56sAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt56sAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -50094,8 +49919,7 @@ void CHIPUnitTestingNullableInt56sAttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableInt64sAttributeCallback::CHIPUnitTestingNullableInt64sAttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt64sAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableInt64sAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -50228,8 +50052,7 @@ void CHIPUnitTestingNullableEnum8AttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableEnum16AttributeCallback::CHIPUnitTestingNullableEnum16AttributeCallback(jobject javaCallback,
                                                                                                bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableEnum16AttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableEnum16AttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -50296,8 +50119,7 @@ void CHIPUnitTestingNullableEnum16AttributeCallback::CallbackFn(void * context,
 
 CHIPUnitTestingNullableFloatSingleAttributeCallback::CHIPUnitTestingNullableFloatSingleAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableFloatSingleAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableFloatSingleAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -50364,8 +50186,7 @@ void CHIPUnitTestingNullableFloatSingleAttributeCallback::CallbackFn(void * cont
 
 CHIPUnitTestingNullableFloatDoubleAttributeCallback::CHIPUnitTestingNullableFloatDoubleAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableFloatDoubleAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableFloatDoubleAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -50432,8 +50253,7 @@ void CHIPUnitTestingNullableFloatDoubleAttributeCallback::CallbackFn(void * cont
 
 CHIPUnitTestingNullableOctetStringAttributeCallback::CHIPUnitTestingNullableOctetStringAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableOctetStringAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableOctetStringAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -50499,8 +50319,7 @@ void CHIPUnitTestingNullableOctetStringAttributeCallback::CallbackFn(void * cont
 
 CHIPUnitTestingNullableCharStringAttributeCallback::CHIPUnitTestingNullableCharStringAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableCharStringAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableCharStringAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -50563,8 +50382,7 @@ void CHIPUnitTestingNullableCharStringAttributeCallback::CallbackFn(void * conte
 
 CHIPUnitTestingNullableEnumAttrAttributeCallback::CHIPUnitTestingNullableEnumAttrAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterNullableEnumAttrAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterNullableEnumAttrAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -50975,8 +50793,7 @@ void CHIPUnitTestingGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPUnitTestingAcceptedCommandListAttributeCallback::CHIPUnitTestingAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                          bool keepAlive) :
-    chip::Callback::Callback<CHIPUnitTestingClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPUnitTestingClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -51401,8 +51218,7 @@ void CHIPFaultInjectionEventListAttributeCallback::CallbackFn(void * context,
 
 CHIPFaultInjectionAttributeListAttributeCallback::CHIPFaultInjectionAttributeListAttributeCallback(jobject javaCallback,
                                                                                                    bool keepAlive) :
-    chip::Callback::Callback<CHIPFaultInjectionClusterAttributeListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPFaultInjectionClusterAttributeListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -51473,8 +51289,7 @@ void CHIPFaultInjectionAttributeListAttributeCallback::CallbackFn(
 
 CHIPSampleMeiGeneratedCommandListAttributeCallback::CHIPSampleMeiGeneratedCommandListAttributeCallback(jobject javaCallback,
                                                                                                        bool keepAlive) :
-    chip::Callback::Callback<CHIPSampleMeiClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPSampleMeiClusterGeneratedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
@@ -51545,8 +51360,7 @@ void CHIPSampleMeiGeneratedCommandListAttributeCallback::CallbackFn(
 
 CHIPSampleMeiAcceptedCommandListAttributeCallback::CHIPSampleMeiAcceptedCommandListAttributeCallback(jobject javaCallback,
                                                                                                      bool keepAlive) :
-    chip::Callback::Callback<CHIPSampleMeiClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this),
-    keepAlive(keepAlive)
+    chip::Callback::Callback<CHIPSampleMeiClusterAcceptedCommandListAttributeCallbackType>(CallbackFn, this), keepAlive(keepAlive)
 {
     JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread();
     if (env == nullptr)
diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm
index e71553fa5489b3..ec55b1beca255a 100644
--- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm
@@ -144,27 +144,21 @@ - (void)writeAttributeIdentifyTimeWithValue:(NSNumber * _Nonnull)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = Identify::Attributes::IdentifyTime::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -2910,27 +2904,21 @@ - (void)writeAttributeOnTimeWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = OnOff::Attributes::OnTime::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -2980,27 +2968,21 @@ - (void)writeAttributeOffWaitTimeWithValue:(NSNumber * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = OnOff::Attributes::OffWaitTime::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -3050,32 +3032,26 @@ - (void)writeAttributeStartUpOnOffWithValue:(NSNumber * _Nullable)value params:(
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = OnOff::Attributes::StartUpOnOff::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                  nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -3825,27 +3801,21 @@ - (void)writeAttributeSwitchActionsWithValue:(NSNumber * _Nonnull)value params:(
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchActions::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -4860,27 +4830,21 @@ - (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value params:(MTRWri
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = LevelControl::Attributes::Options::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -4930,27 +4894,21 @@ - (void)writeAttributeOnOffTransitionTimeWithValue:(NSNumber * _Nonnull)value pa
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = LevelControl::Attributes::OnOffTransitionTime::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -5000,32 +4958,26 @@ - (void)writeAttributeOnLevelWithValue:(NSNumber * _Nullable)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = LevelControl::Attributes::OnLevel::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -5075,32 +5027,26 @@ - (void)writeAttributeOnTransitionTimeWithValue:(NSNumber * _Nullable)value para
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedShortValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = LevelControl::Attributes::OnTransitionTime::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedShortValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -5150,32 +5096,26 @@ - (void)writeAttributeOffTransitionTimeWithValue:(NSNumber * _Nullable)value par
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedShortValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = LevelControl::Attributes::OffTransitionTime::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedShortValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -5225,32 +5165,26 @@ - (void)writeAttributeDefaultMoveRateWithValue:(NSNumber * _Nullable)value param
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = LevelControl::Attributes::DefaultMoveRate::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -5300,32 +5234,26 @@ - (void)writeAttributeStartUpCurrentLevelWithValue:(NSNumber * _Nullable)value p
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = LevelControl::Attributes::StartUpCurrentLevel::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -6385,27 +6313,21 @@ - (void)writeAttributeActiveTextWithValue:(NSString * _Nonnull)value params:(MTR
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsCharSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = BinaryInputBasic::Attributes::ActiveText::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsCharSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -6455,27 +6377,21 @@ - (void)writeAttributeDescriptionWithValue:(NSString * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsCharSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = BinaryInputBasic::Attributes::Description::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsCharSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -6525,27 +6441,21 @@ - (void)writeAttributeInactiveTextWithValue:(NSString * _Nonnull)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsCharSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = BinaryInputBasic::Attributes::InactiveText::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsCharSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -6595,27 +6505,21 @@ - (void)writeAttributeOutOfServiceWithValue:(NSNumber * _Nonnull)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = BinaryInputBasic::Attributes::OutOfService::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -6701,27 +6605,21 @@ - (void)writeAttributePresentValueWithValue:(NSNumber * _Nonnull)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = BinaryInputBasic::Attributes::PresentValue::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -6771,27 +6669,21 @@ - (void)writeAttributeReliabilityWithValue:(NSNumber * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = BinaryInputBasic::Attributes::Reliability::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -8664,64 +8556,58 @@ - (void)writeAttributeBindingWithValue:(NSArray * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Binding::Attributes::Binding::TypeInfo;
-            TypeInfo::Type cppValue;
-            {
-                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (value.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
-                        if (![value[i_0] isKindOfClass:[MTRBindingClusterTargetStruct class]]) {
-                            // Wrong kind of value.
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        auto element_0 = (MTRBindingClusterTargetStruct *) value[i_0];
-                        if (element_0.node != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].node.Emplace();
-                            definedValue_2 = element_0.node.unsignedLongLongValue;
-                        }
-                        if (element_0.group != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].group.Emplace();
-                            definedValue_2 = element_0.group.unsignedShortValue;
-                        }
-                        if (element_0.endpoint != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].endpoint.Emplace();
-                            definedValue_2 = element_0.endpoint.unsignedShortValue;
-                        }
-                        if (element_0.cluster != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].cluster.Emplace();
-                            definedValue_2 = element_0.cluster.unsignedIntValue;
-                        }
-                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
-                    }
-                    cppValue = ListType_0(listHolder_0->mList, value.count);
-                } else {
-                    cppValue = ListType_0();
+        ListFreer listFreer;
+        using TypeInfo = Binding::Attributes::Binding::TypeInfo;
+        TypeInfo::Type cppValue;
+          {
+            using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
+            using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+            if (value.count != 0) {
+              auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
+              if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
+                return CHIP_ERROR_INVALID_ARGUMENT;
+              }
+              listFreer.add(listHolder_0);
+              for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
+                if ( ! [value[i_0] isKindOfClass: [MTRBindingClusterTargetStruct class]] ) {
+                  // Wrong kind of value.
+                  return CHIP_ERROR_INVALID_ARGUMENT;
                 }
+                auto element_0 = (MTRBindingClusterTargetStruct *)value[i_0];
+                       if (element_0.node != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].node.Emplace();
+                 definedValue_2 = element_0.node.unsignedLongLongValue;
+  }
+       if (element_0.group != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].group.Emplace();
+                 definedValue_2 = element_0.group.unsignedShortValue;
+  }
+       if (element_0.endpoint != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].endpoint.Emplace();
+                 definedValue_2 = element_0.endpoint.unsignedShortValue;
+  }
+       if (element_0.cluster != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].cluster.Emplace();
+                 definedValue_2 = element_0.cluster.unsignedIntValue;
+  }
+             listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
+      }
+              cppValue = ListType_0(listHolder_0->mList, value.count);
+            } else {
+              cppValue = ListType_0();
             }
+          }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -9232,121 +9118,115 @@ - (void)writeAttributeACLWithValue:(NSArray * _Nonnull)value params:(MTRWritePar
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
-            TypeInfo::Type cppValue;
-            {
-                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (value.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
-                        if (![value[i_0] isKindOfClass:[MTRAccessControlClusterAccessControlEntryStruct class]]) {
-                            // Wrong kind of value.
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        auto element_0 = (MTRAccessControlClusterAccessControlEntryStruct *) value[i_0];
-                        listHolder_0->mList[i_0].privilege = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].privilege)>>(element_0.privilege.unsignedCharValue);
-                        listHolder_0->mList[i_0].authMode = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].authMode)>>(element_0.authMode.unsignedCharValue);
-                        if (element_0.subjects == nil) {
-                            listHolder_0->mList[i_0].subjects.SetNull();
-                        } else {
-                            auto & nonNullValue_2 = listHolder_0->mList[i_0].subjects.SetNonNull();
-                            {
-                                using ListType_3 = std::remove_reference_t<decltype(nonNullValue_2)>;
-                                using ListMemberType_3 = ListMemberTypeGetter<ListType_3>::Type;
-                                if (element_0.subjects.count != 0) {
-                                    auto * listHolder_3 = new ListHolder<ListMemberType_3>(element_0.subjects.count);
-                                    if (listHolder_3 == nullptr || listHolder_3->mList == nullptr) {
-                                        return CHIP_ERROR_INVALID_ARGUMENT;
-                                    }
-                                    listFreer.add(listHolder_3);
-                                    for (size_t i_3 = 0; i_3 < element_0.subjects.count; ++i_3) {
-                                        if (![element_0.subjects[i_3] isKindOfClass:[NSNumber class]]) {
-                                            // Wrong kind of value.
-                                            return CHIP_ERROR_INVALID_ARGUMENT;
-                                        }
-                                        auto element_3 = (NSNumber *) element_0.subjects[i_3];
-                                        listHolder_3->mList[i_3] = element_3.unsignedLongLongValue;
-                                    }
-                                    nonNullValue_2 = ListType_3(listHolder_3->mList, element_0.subjects.count);
-                                } else {
-                                    nonNullValue_2 = ListType_3();
-                                }
-                            }
-                        }
-                        if (element_0.targets == nil) {
-                            listHolder_0->mList[i_0].targets.SetNull();
-                        } else {
-                            auto & nonNullValue_2 = listHolder_0->mList[i_0].targets.SetNonNull();
-                            {
-                                using ListType_3 = std::remove_reference_t<decltype(nonNullValue_2)>;
-                                using ListMemberType_3 = ListMemberTypeGetter<ListType_3>::Type;
-                                if (element_0.targets.count != 0) {
-                                    auto * listHolder_3 = new ListHolder<ListMemberType_3>(element_0.targets.count);
-                                    if (listHolder_3 == nullptr || listHolder_3->mList == nullptr) {
-                                        return CHIP_ERROR_INVALID_ARGUMENT;
-                                    }
-                                    listFreer.add(listHolder_3);
-                                    for (size_t i_3 = 0; i_3 < element_0.targets.count; ++i_3) {
-                                        if (![element_0.targets[i_3] isKindOfClass:[MTRAccessControlClusterAccessControlTargetStruct class]]) {
-                                            // Wrong kind of value.
-                                            return CHIP_ERROR_INVALID_ARGUMENT;
-                                        }
-                                        auto element_3 = (MTRAccessControlClusterAccessControlTargetStruct *) element_0.targets[i_3];
-                                        if (element_3.cluster == nil) {
-                                            listHolder_3->mList[i_3].cluster.SetNull();
-                                        } else {
-                                            auto & nonNullValue_5 = listHolder_3->mList[i_3].cluster.SetNonNull();
-                                            nonNullValue_5 = element_3.cluster.unsignedIntValue;
-                                        }
-                                        if (element_3.endpoint == nil) {
-                                            listHolder_3->mList[i_3].endpoint.SetNull();
-                                        } else {
-                                            auto & nonNullValue_5 = listHolder_3->mList[i_3].endpoint.SetNonNull();
-                                            nonNullValue_5 = element_3.endpoint.unsignedShortValue;
-                                        }
-                                        if (element_3.deviceType == nil) {
-                                            listHolder_3->mList[i_3].deviceType.SetNull();
-                                        } else {
-                                            auto & nonNullValue_5 = listHolder_3->mList[i_3].deviceType.SetNonNull();
-                                            nonNullValue_5 = element_3.deviceType.unsignedIntValue;
-                                        }
-                                    }
-                                    nonNullValue_2 = ListType_3(listHolder_3->mList, element_0.targets.count);
-                                } else {
-                                    nonNullValue_2 = ListType_3();
-                                }
-                            }
-                        }
-                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
-                    }
-                    cppValue = ListType_0(listHolder_0->mList, value.count);
-                } else {
-                    cppValue = ListType_0();
+        ListFreer listFreer;
+        using TypeInfo = AccessControl::Attributes::Acl::TypeInfo;
+        TypeInfo::Type cppValue;
+          {
+            using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
+            using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+            if (value.count != 0) {
+              auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
+              if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
+                return CHIP_ERROR_INVALID_ARGUMENT;
+              }
+              listFreer.add(listHolder_0);
+              for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
+                if ( ! [value[i_0] isKindOfClass: [MTRAccessControlClusterAccessControlEntryStruct class]] ) {
+                  // Wrong kind of value.
+                  return CHIP_ERROR_INVALID_ARGUMENT;
                 }
+                auto element_0 = (MTRAccessControlClusterAccessControlEntryStruct *)value[i_0];
+                           listHolder_0->mList[i_0].privilege = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].privilege)>>(element_0.privilege.unsignedCharValue);
+           listHolder_0->mList[i_0].authMode = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].authMode)>>(element_0.authMode.unsignedCharValue);
+       if (element_0.subjects == nil) {
+         listHolder_0->mList[i_0].subjects.SetNull();
+       } else {
+         auto & nonNullValue_2 = listHolder_0->mList[i_0].subjects.SetNonNull();
+           {
+             using ListType_3 = std::remove_reference_t<decltype(nonNullValue_2)>;
+             using ListMemberType_3 = ListMemberTypeGetter<ListType_3>::Type;
+             if (element_0.subjects.count != 0) {
+               auto * listHolder_3 = new ListHolder<ListMemberType_3>(element_0.subjects.count);
+               if (listHolder_3 == nullptr || listHolder_3->mList == nullptr) {
+                 return CHIP_ERROR_INVALID_ARGUMENT;
+               }
+               listFreer.add(listHolder_3);
+               for (size_t i_3 = 0; i_3 < element_0.subjects.count; ++i_3) {
+                 if ( ! [element_0.subjects[i_3] isKindOfClass: [NSNumber class]] ) {
+                   // Wrong kind of value.
+                   return CHIP_ERROR_INVALID_ARGUMENT;
+                 }
+                 auto element_3 = (NSNumber *)element_0.subjects[i_3];
+                         listHolder_3->mList[i_3] = element_3.unsignedLongLongValue;
+      }
+               nonNullValue_2 = ListType_3(listHolder_3->mList, element_0.subjects.count);
+             } else {
+               nonNullValue_2 = ListType_3();
+             }
+           }
+       }
+       if (element_0.targets == nil) {
+         listHolder_0->mList[i_0].targets.SetNull();
+       } else {
+         auto & nonNullValue_2 = listHolder_0->mList[i_0].targets.SetNonNull();
+           {
+             using ListType_3 = std::remove_reference_t<decltype(nonNullValue_2)>;
+             using ListMemberType_3 = ListMemberTypeGetter<ListType_3>::Type;
+             if (element_0.targets.count != 0) {
+               auto * listHolder_3 = new ListHolder<ListMemberType_3>(element_0.targets.count);
+               if (listHolder_3 == nullptr || listHolder_3->mList == nullptr) {
+                 return CHIP_ERROR_INVALID_ARGUMENT;
+               }
+               listFreer.add(listHolder_3);
+               for (size_t i_3 = 0; i_3 < element_0.targets.count; ++i_3) {
+                 if ( ! [element_0.targets[i_3] isKindOfClass: [MTRAccessControlClusterAccessControlTargetStruct class]] ) {
+                   // Wrong kind of value.
+                   return CHIP_ERROR_INVALID_ARGUMENT;
+                 }
+                 auto element_3 = (MTRAccessControlClusterAccessControlTargetStruct *)element_0.targets[i_3];
+                        if (element_3.cluster == nil) {
+         listHolder_3->mList[i_3].cluster.SetNull();
+       } else {
+         auto & nonNullValue_5 = listHolder_3->mList[i_3].cluster.SetNonNull();
+                 nonNullValue_5 = element_3.cluster.unsignedIntValue;
+  }
+       if (element_3.endpoint == nil) {
+         listHolder_3->mList[i_3].endpoint.SetNull();
+       } else {
+         auto & nonNullValue_5 = listHolder_3->mList[i_3].endpoint.SetNonNull();
+                 nonNullValue_5 = element_3.endpoint.unsignedShortValue;
+  }
+       if (element_3.deviceType == nil) {
+         listHolder_3->mList[i_3].deviceType.SetNull();
+       } else {
+         auto & nonNullValue_5 = listHolder_3->mList[i_3].deviceType.SetNonNull();
+                 nonNullValue_5 = element_3.deviceType.unsignedIntValue;
+  }
+      }
+               nonNullValue_2 = ListType_3(listHolder_3->mList, element_0.targets.count);
+             } else {
+               nonNullValue_2 = ListType_3();
+             }
+           }
+       }
+             listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
+      }
+              cppValue = ListType_0(listHolder_0->mList, value.count);
+            } else {
+              cppValue = ListType_0();
             }
+          }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -9396,49 +9276,43 @@ - (void)writeAttributeExtensionWithValue:(NSArray * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
-            TypeInfo::Type cppValue;
-            {
-                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (value.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
-                        if (![value[i_0] isKindOfClass:[MTRAccessControlClusterAccessControlExtensionStruct class]]) {
-                            // Wrong kind of value.
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        auto element_0 = (MTRAccessControlClusterAccessControlExtensionStruct *) value[i_0];
-                        listHolder_0->mList[i_0].data = AsByteSpan(element_0.data);
-                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
-                    }
-                    cppValue = ListType_0(listHolder_0->mList, value.count);
-                } else {
-                    cppValue = ListType_0();
+        ListFreer listFreer;
+        using TypeInfo = AccessControl::Attributes::Extension::TypeInfo;
+        TypeInfo::Type cppValue;
+          {
+            using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
+            using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+            if (value.count != 0) {
+              auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
+              if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
+                return CHIP_ERROR_INVALID_ARGUMENT;
+              }
+              listFreer.add(listHolder_0);
+              for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
+                if ( ! [value[i_0] isKindOfClass: [MTRAccessControlClusterAccessControlExtensionStruct class]] ) {
+                  // Wrong kind of value.
+                  return CHIP_ERROR_INVALID_ARGUMENT;
                 }
+                auto element_0 = (MTRAccessControlClusterAccessControlExtensionStruct *)value[i_0];
+                       listHolder_0->mList[i_0].data = AsByteSpan(element_0.data);
+             listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
+      }
+              cppValue = ListType_0(listHolder_0->mList, value.count);
+            } else {
+              cppValue = ListType_0();
             }
+          }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -11395,27 +11269,21 @@ - (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value params:(MTRW
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BasicInformation::Attributes::NodeLabel::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsCharSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = BasicInformation::Attributes::NodeLabel::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsCharSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -11465,27 +11333,21 @@ - (void)writeAttributeLocationWithValue:(NSString * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BasicInformation::Attributes::Location::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsCharSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = BasicInformation::Attributes::Location::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsCharSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -11859,27 +11721,21 @@ - (void)writeAttributeLocalConfigDisabledWithValue:(NSNumber * _Nonnull)value pa
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BasicInformation::Attributes::LocalConfigDisabled::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = BasicInformation::Attributes::LocalConfigDisabled::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -13769,50 +13625,44 @@ - (void)writeAttributeDefaultOTAProvidersWithValue:(NSArray * _Nonnull)value par
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOTAProviders::TypeInfo;
-            TypeInfo::Type cppValue;
-            {
-                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (value.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
-                        if (![value[i_0] isKindOfClass:[MTROTASoftwareUpdateRequestorClusterProviderLocation class]]) {
-                            // Wrong kind of value.
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        auto element_0 = (MTROTASoftwareUpdateRequestorClusterProviderLocation *) value[i_0];
-                        listHolder_0->mList[i_0].providerNodeID = element_0.providerNodeID.unsignedLongLongValue;
-                        listHolder_0->mList[i_0].endpoint = element_0.endpoint.unsignedShortValue;
-                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
-                    }
-                    cppValue = ListType_0(listHolder_0->mList, value.count);
-                } else {
-                    cppValue = ListType_0();
+        ListFreer listFreer;
+        using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::DefaultOTAProviders::TypeInfo;
+        TypeInfo::Type cppValue;
+          {
+            using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
+            using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+            if (value.count != 0) {
+              auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
+              if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
+                return CHIP_ERROR_INVALID_ARGUMENT;
+              }
+              listFreer.add(listHolder_0);
+              for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
+                if ( ! [value[i_0] isKindOfClass: [MTROTASoftwareUpdateRequestorClusterProviderLocation class]] ) {
+                  // Wrong kind of value.
+                  return CHIP_ERROR_INVALID_ARGUMENT;
                 }
+                auto element_0 = (MTROTASoftwareUpdateRequestorClusterProviderLocation *)value[i_0];
+                             listHolder_0->mList[i_0].providerNodeID = element_0.providerNodeID.unsignedLongLongValue;
+             listHolder_0->mList[i_0].endpoint = element_0.endpoint.unsignedShortValue;
+             listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
+      }
+              cppValue = ListType_0(listHolder_0->mList, value.count);
+            } else {
+              cppValue = ListType_0();
             }
+          }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -14545,27 +14395,21 @@ - (void)writeAttributeActiveLocaleWithValue:(NSString * _Nonnull)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsCharSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = LocalizationConfiguration::Attributes::ActiveLocale::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsCharSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -15147,27 +14991,21 @@ - (void)writeAttributeHourFormatWithValue:(NSNumber * _Nonnull)value params:(MTR
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = TimeFormatLocalization::Attributes::HourFormat::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -15217,27 +15055,21 @@ - (void)writeAttributeActiveCalendarTypeWithValue:(NSNumber * _Nonnull)value par
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = TimeFormatLocalization::Attributes::ActiveCalendarType::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -15862,27 +15694,21 @@ - (void)writeAttributeTemperatureUnitWithValue:(NSNumber * _Nonnull)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = UnitLocalization::Attributes::TemperatureUnit::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -19614,27 +19440,21 @@ - (void)writeAttributeBreadcrumbWithValue:(NSNumber * _Nonnull)value params:(MTR
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedLongLongValue;
+        ListFreer listFreer;
+        using TypeInfo = GeneralCommissioning::Attributes::Breadcrumb::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedLongLongValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -20747,27 +20567,21 @@ - (void)writeAttributeInterfaceEnabledWithValue:(NSNumber * _Nonnull)value param
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = NetworkCommissioning::Attributes::InterfaceEnabled::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -32440,27 +32254,21 @@ - (void)writeAttributeNodeLabelWithValue:(NSString * _Nonnull)value params:(MTRW
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BridgedDeviceBasicInformation::Attributes::NodeLabel::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsCharSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = BridgedDeviceBasicInformation::Attributes::NodeLabel::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsCharSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -36464,50 +36272,44 @@ - (void)writeAttributeGroupKeyMapWithValue:(NSArray * _Nonnull)value params:(MTR
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
-            TypeInfo::Type cppValue;
-            {
-                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (value.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
-                        if (![value[i_0] isKindOfClass:[MTRGroupKeyManagementClusterGroupKeyMapStruct class]]) {
-                            // Wrong kind of value.
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        auto element_0 = (MTRGroupKeyManagementClusterGroupKeyMapStruct *) value[i_0];
-                        listHolder_0->mList[i_0].groupId = element_0.groupId.unsignedShortValue;
-                        listHolder_0->mList[i_0].groupKeySetID = element_0.groupKeySetID.unsignedShortValue;
-                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
-                    }
-                    cppValue = ListType_0(listHolder_0->mList, value.count);
-                } else {
-                    cppValue = ListType_0();
+        ListFreer listFreer;
+        using TypeInfo = GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo;
+        TypeInfo::Type cppValue;
+          {
+            using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
+            using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+            if (value.count != 0) {
+              auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
+              if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
+                return CHIP_ERROR_INVALID_ARGUMENT;
+              }
+              listFreer.add(listHolder_0);
+              for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
+                if ( ! [value[i_0] isKindOfClass: [MTRGroupKeyManagementClusterGroupKeyMapStruct class]] ) {
+                  // Wrong kind of value.
+                  return CHIP_ERROR_INVALID_ARGUMENT;
                 }
+                auto element_0 = (MTRGroupKeyManagementClusterGroupKeyMapStruct *)value[i_0];
+                             listHolder_0->mList[i_0].groupId = element_0.groupId.unsignedShortValue;
+             listHolder_0->mList[i_0].groupKeySetID = element_0.groupKeySetID.unsignedShortValue;
+             listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
+      }
+              cppValue = ListType_0(listHolder_0->mList, value.count);
+            } else {
+              cppValue = ListType_0();
             }
+          }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -37747,49 +37549,43 @@ - (void)writeAttributeLabelListWithValue:(NSArray * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
-            TypeInfo::Type cppValue;
-            {
-                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (value.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
-                        if (![value[i_0] isKindOfClass:[MTRUserLabelClusterLabelStruct class]]) {
-                            // Wrong kind of value.
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        auto element_0 = (MTRUserLabelClusterLabelStruct *) value[i_0];
-                        listHolder_0->mList[i_0].label = AsCharSpan(element_0.label);
-                        listHolder_0->mList[i_0].value = AsCharSpan(element_0.value);
-                    }
-                    cppValue = ListType_0(listHolder_0->mList, value.count);
-                } else {
-                    cppValue = ListType_0();
+        ListFreer listFreer;
+        using TypeInfo = UserLabel::Attributes::LabelList::TypeInfo;
+        TypeInfo::Type cppValue;
+          {
+            using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
+            using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+            if (value.count != 0) {
+              auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
+              if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
+                return CHIP_ERROR_INVALID_ARGUMENT;
+              }
+              listFreer.add(listHolder_0);
+              for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
+                if ( ! [value[i_0] isKindOfClass: [MTRUserLabelClusterLabelStruct class]] ) {
+                  // Wrong kind of value.
+                  return CHIP_ERROR_INVALID_ARGUMENT;
                 }
+                auto element_0 = (MTRUserLabelClusterLabelStruct *)value[i_0];
+                       listHolder_0->mList[i_0].label = AsCharSpan(element_0.label);
+       listHolder_0->mList[i_0].value = AsCharSpan(element_0.value);
+      }
+              cppValue = ListType_0(listHolder_0->mList, value.count);
+            } else {
+              cppValue = ListType_0();
             }
+          }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -39555,32 +39351,26 @@ - (void)writeAttributeStartUpModeWithValue:(NSNumber * _Nullable)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = ModeSelect::Attributes::StartUpMode::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -39630,32 +39420,26 @@ - (void)writeAttributeOnModeWithValue:(NSNumber * _Nullable)value params:(MTRWri
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = ModeSelect::Attributes::OnMode::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -40452,32 +40236,26 @@ - (void)writeAttributeStartUpModeWithValue:(NSNumber * _Nullable)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = LaundryWasherMode::Attributes::StartUpMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = LaundryWasherMode::Attributes::StartUpMode::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -40527,32 +40305,26 @@ - (void)writeAttributeOnModeWithValue:(NSNumber * _Nullable)value params:(MTRWri
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = LaundryWasherMode::Attributes::OnMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = LaundryWasherMode::Attributes::OnMode::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -40931,32 +40703,26 @@ - (void)writeAttributeStartUpModeWithValue:(NSNumber * _Nullable)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::StartUpMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::StartUpMode::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -41006,32 +40772,26 @@ - (void)writeAttributeOnModeWithValue:(NSNumber * _Nullable)value params:(MTRWri
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::OnMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = RefrigeratorAndTemperatureControlledCabinetMode::Attributes::OnMode::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -41349,32 +41109,26 @@ - (void)writeAttributeSpinSpeedCurrentWithValue:(NSNumber * _Nullable)value para
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = LaundryWasherControls::Attributes::SpinSpeedCurrent::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = LaundryWasherControls::Attributes::SpinSpeedCurrent::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -41424,27 +41178,21 @@ - (void)writeAttributeNumberOfRinsesWithValue:(NSNumber * _Nonnull)value params:
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = LaundryWasherControls::Attributes::NumberOfRinses::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = LaundryWasherControls::Attributes::NumberOfRinses::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -41859,32 +41607,26 @@ - (void)writeAttributeOnModeWithValue:(NSNumber * _Nullable)value params:(MTRWri
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = RvcRunMode::Attributes::OnMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = RvcRunMode::Attributes::OnMode::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -42263,32 +42005,26 @@ - (void)writeAttributeOnModeWithValue:(NSNumber * _Nullable)value params:(MTRWri
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = RvcCleanMode::Attributes::OnMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = RvcCleanMode::Attributes::OnMode::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -43480,32 +43216,26 @@ - (void)writeAttributeStartUpModeWithValue:(NSNumber * _Nullable)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = DishwasherMode::Attributes::StartUpMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = DishwasherMode::Attributes::StartUpMode::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -43555,32 +43285,26 @@ - (void)writeAttributeOnModeWithValue:(NSNumber * _Nullable)value params:(MTRWri
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = DishwasherMode::Attributes::OnMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = DishwasherMode::Attributes::OnMode::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -44555,27 +44279,21 @@ - (void)writeAttributeSmokeSensitivityLevelWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = SmokeCoAlarm::Attributes::SmokeSensitivityLevel::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = SmokeCoAlarm::Attributes::SmokeSensitivityLevel::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -46613,32 +46331,26 @@ - (void)writeAttributeLastChangedTimeWithValue:(NSNumber * _Nullable)value param
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = HepaFilterMonitoring::Attributes::LastChangedTime::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedIntValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = HepaFilterMonitoring::Attributes::LastChangedTime::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedIntValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -47129,32 +46841,26 @@ - (void)writeAttributeLastChangedTimeWithValue:(NSNumber * _Nullable)value param
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::LastChangedTime::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedIntValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = ActivatedCarbonFilterMonitoring::Attributes::LastChangedTime::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedIntValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -48097,27 +47803,21 @@ - (void)writeAttributeDoorOpenEventsWithValue:(NSNumber * _Nonnull)value params:
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedIntValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::DoorOpenEvents::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedIntValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -48167,27 +47867,21 @@ - (void)writeAttributeDoorClosedEventsWithValue:(NSNumber * _Nonnull)value param
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedIntValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::DoorClosedEvents::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedIntValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -48237,27 +47931,21 @@ - (void)writeAttributeOpenPeriodWithValue:(NSNumber * _Nonnull)value params:(MTR
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::OpenPeriod::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -48739,27 +48427,21 @@ - (void)writeAttributeLanguageWithValue:(NSString * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsCharSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::Language::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsCharSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -48809,27 +48491,21 @@ - (void)writeAttributeLEDSettingsWithValue:(NSNumber * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::LEDSettings::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -48879,27 +48555,21 @@ - (void)writeAttributeAutoRelockTimeWithValue:(NSNumber * _Nonnull)value params:
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedIntValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::AutoRelockTime::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedIntValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -48949,27 +48619,21 @@ - (void)writeAttributeSoundVolumeWithValue:(NSNumber * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::SoundVolume::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -49019,27 +48683,21 @@ - (void)writeAttributeOperatingModeWithValue:(NSNumber * _Nonnull)value params:(
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::OperatingMode::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -49161,27 +48819,21 @@ - (void)writeAttributeEnableLocalProgrammingWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::EnableLocalProgramming::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -49231,27 +48883,21 @@ - (void)writeAttributeEnableOneTouchLockingWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::EnableOneTouchLocking::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -49301,27 +48947,21 @@ - (void)writeAttributeEnableInsideStatusLEDWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::EnableInsideStatusLED::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -49371,27 +49011,21 @@ - (void)writeAttributeEnablePrivacyModeButtonWithValue:(NSNumber * _Nonnull)valu
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::EnablePrivacyModeButton::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -49441,27 +49075,21 @@ - (void)writeAttributeLocalProgrammingFeaturesWithValue:(NSNumber * _Nonnull)val
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::LocalProgrammingFeatures::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -49511,27 +49139,21 @@ - (void)writeAttributeWrongCodeEntryLimitWithValue:(NSNumber * _Nonnull)value pa
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::WrongCodeEntryLimit::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -49581,27 +49203,21 @@ - (void)writeAttributeUserCodeTemporaryDisableTimeWithValue:(NSNumber * _Nonnull
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::UserCodeTemporaryDisableTime::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -49651,27 +49267,21 @@ - (void)writeAttributeSendPINOverTheAirWithValue:(NSNumber * _Nonnull)value para
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::SendPINOverTheAir::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -49721,27 +49331,21 @@ - (void)writeAttributeRequirePINforRemoteOperationWithValue:(NSNumber * _Nonnull
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::RequirePINforRemoteOperation::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -49791,27 +49395,21 @@ - (void)writeAttributeExpiringUserTimeoutWithValue:(NSNumber * _Nonnull)value pa
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = DoorLock::Attributes::ExpiringUserTimeout::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -52693,27 +52291,21 @@ - (void)writeAttributeModeWithValue:(NSNumber * _Nonnull)value params:(MTRWriteP
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = WindowCovering::Attributes::Mode::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -54204,27 +53796,21 @@ - (void)writeAttributeBarrierOpenEventsWithValue:(NSNumber * _Nonnull)value para
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = BarrierControl::Attributes::BarrierOpenEvents::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -54274,27 +53860,21 @@ - (void)writeAttributeBarrierCloseEventsWithValue:(NSNumber * _Nonnull)value par
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = BarrierControl::Attributes::BarrierCloseEvents::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -54344,27 +53924,21 @@ - (void)writeAttributeBarrierCommandOpenEventsWithValue:(NSNumber * _Nonnull)val
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = BarrierControl::Attributes::BarrierCommandOpenEvents::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -54414,27 +53988,21 @@ - (void)writeAttributeBarrierCommandCloseEventsWithValue:(NSNumber * _Nonnull)va
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = BarrierControl::Attributes::BarrierCommandCloseEvents::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -54484,27 +54052,21 @@ - (void)writeAttributeBarrierOpenPeriodWithValue:(NSNumber * _Nonnull)value para
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = BarrierControl::Attributes::BarrierOpenPeriod::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -54554,27 +54116,21 @@ - (void)writeAttributeBarrierClosePeriodWithValue:(NSNumber * _Nonnull)value par
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = BarrierControl::Attributes::BarrierClosePeriod::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -56139,32 +55695,26 @@ - (void)writeAttributeLifetimeRunningHoursWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedIntValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeRunningHours::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedIntValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -56250,32 +55800,26 @@ - (void)writeAttributeLifetimeEnergyConsumedWithValue:(NSNumber * _Nullable)valu
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedIntValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedIntValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -56325,27 +55869,21 @@ - (void)writeAttributeOperationModeWithValue:(NSNumber * _Nonnull)value params:(
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = PumpConfigurationAndControl::Attributes::OperationMode::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -56395,27 +55933,21 @@ - (void)writeAttributeControlModeWithValue:(NSNumber * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = PumpConfigurationAndControl::Attributes::ControlMode::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -58145,27 +57677,21 @@ - (void)writeAttributeHVACSystemTypeConfigurationWithValue:(NSNumber * _Nonnull)
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::HVACSystemTypeConfiguration::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -58215,27 +57741,21 @@ - (void)writeAttributeLocalTemperatureCalibrationWithValue:(NSNumber * _Nonnull)
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.charValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::LocalTemperatureCalibration::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.charValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -58285,27 +57805,21 @@ - (void)writeAttributeOccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)valu
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.shortValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::OccupiedCoolingSetpoint::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.shortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -58355,27 +57869,21 @@ - (void)writeAttributeOccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)valu
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.shortValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::OccupiedHeatingSetpoint::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.shortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -58425,27 +57933,21 @@ - (void)writeAttributeUnoccupiedCoolingSetpointWithValue:(NSNumber * _Nonnull)va
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.shortValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::UnoccupiedCoolingSetpoint::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.shortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -58495,27 +57997,21 @@ - (void)writeAttributeUnoccupiedHeatingSetpointWithValue:(NSNumber * _Nonnull)va
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.shortValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::UnoccupiedHeatingSetpoint::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.shortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -58565,27 +58061,21 @@ - (void)writeAttributeMinHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value p
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.shortValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::MinHeatSetpointLimit::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.shortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -58635,27 +58125,21 @@ - (void)writeAttributeMaxHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value p
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.shortValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::MaxHeatSetpointLimit::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.shortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -58705,27 +58189,21 @@ - (void)writeAttributeMinCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value p
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.shortValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::MinCoolSetpointLimit::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.shortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -58775,27 +58253,21 @@ - (void)writeAttributeMaxCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value p
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.shortValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::MaxCoolSetpointLimit::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.shortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -58845,27 +58317,21 @@ - (void)writeAttributeMinSetpointDeadBandWithValue:(NSNumber * _Nonnull)value pa
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.charValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::MinSetpointDeadBand::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.charValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -58915,27 +58381,21 @@ - (void)writeAttributeRemoteSensingWithValue:(NSNumber * _Nonnull)value params:(
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::RemoteSensing::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -58985,27 +58445,21 @@ - (void)writeAttributeControlSequenceOfOperationWithValue:(NSNumber * _Nonnull)v
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::ControlSequenceOfOperation::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -59055,27 +58509,21 @@ - (void)writeAttributeSystemModeWithValue:(NSNumber * _Nonnull)value params:(MTR
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::SystemMode::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -59269,27 +58717,21 @@ - (void)writeAttributeTemperatureSetpointHoldWithValue:(NSNumber * _Nonnull)valu
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::TemperatureSetpointHold::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -59339,32 +58781,26 @@ - (void)writeAttributeTemperatureSetpointHoldDurationWithValue:(NSNumber * _Null
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedShortValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::TemperatureSetpointHoldDuration::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedShortValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -59414,27 +58850,21 @@ - (void)writeAttributeThermostatProgrammingOperationModeWithValue:(NSNumber * _N
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::ThermostatProgrammingOperationMode::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -59628,32 +59058,26 @@ - (void)writeAttributeOccupiedSetbackWithValue:(NSNumber * _Nullable)value param
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::OccupiedSetback::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -59775,32 +59199,26 @@ - (void)writeAttributeUnoccupiedSetbackWithValue:(NSNumber * _Nullable)value par
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::UnoccupiedSetback::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -59922,27 +59340,21 @@ - (void)writeAttributeEmergencyHeatDeltaWithValue:(NSNumber * _Nonnull)value par
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::EmergencyHeatDelta::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -59992,27 +59404,21 @@ - (void)writeAttributeACTypeWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::ACType::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -60062,27 +59468,21 @@ - (void)writeAttributeACCapacityWithValue:(NSNumber * _Nonnull)value params:(MTR
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::ACCapacity::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -60132,27 +59532,21 @@ - (void)writeAttributeACRefrigerantTypeWithValue:(NSNumber * _Nonnull)value para
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::ACRefrigerantType::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -60202,27 +59596,21 @@ - (void)writeAttributeACCompressorTypeWithValue:(NSNumber * _Nonnull)value param
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::ACCompressorType::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -60272,27 +59660,21 @@ - (void)writeAttributeACErrorCodeWithValue:(NSNumber * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedIntValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::ACErrorCode::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedIntValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -60342,27 +59724,21 @@ - (void)writeAttributeACLouverPositionWithValue:(NSNumber * _Nonnull)value param
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::ACLouverPosition::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -60448,27 +59824,21 @@ - (void)writeAttributeACCapacityformatWithValue:(NSNumber * _Nonnull)value param
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = Thermostat::Attributes::ACCapacityformat::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -62920,27 +62290,21 @@ - (void)writeAttributeFanModeWithValue:(NSNumber * _Nonnull)value params:(MTRWri
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = FanControl::Attributes::FanMode::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -62990,27 +62354,21 @@ - (void)writeAttributeFanModeSequenceWithValue:(NSNumber * _Nonnull)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = FanControl::Attributes::FanModeSequence::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -63060,32 +62418,26 @@ - (void)writeAttributePercentSettingWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = FanControl::Attributes::PercentSetting::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -63207,32 +62559,26 @@ - (void)writeAttributeSpeedSettingWithValue:(NSNumber * _Nullable)value params:(
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = FanControl::Attributes::SpeedSetting::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -63354,27 +62700,21 @@ - (void)writeAttributeRockSettingWithValue:(NSNumber * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = FanControl::Attributes::RockSetting::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -63460,27 +62800,21 @@ - (void)writeAttributeWindSettingWithValue:(NSNumber * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = FanControl::Attributes::WindSetting::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -63530,27 +62864,21 @@ - (void)writeAttributeAirflowDirectionWithValue:(NSNumber * _Nonnull)value param
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = FanControl::Attributes::AirflowDirection::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = FanControl::Attributes::AirflowDirection::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -64451,27 +63779,21 @@ - (void)writeAttributeTemperatureDisplayModeWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -64521,27 +63843,21 @@ - (void)writeAttributeKeypadLockoutWithValue:(NSNumber * _Nonnull)value params:(
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -64591,27 +63907,21 @@ - (void)writeAttributeScheduleProgrammingVisibilityWithValue:(NSNumber * _Nonnul
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -65989,27 +65299,21 @@ - (void)writeAttributeOptionsWithValue:(NSNumber * _Nonnull)value params:(MTRWri
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = ColorControl::Attributes::Options::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -66743,27 +66047,21 @@ - (void)writeAttributeWhitePointXWithValue:(NSNumber * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ColorControl::Attributes::WhitePointX::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -66813,27 +66111,21 @@ - (void)writeAttributeWhitePointYWithValue:(NSNumber * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ColorControl::Attributes::WhitePointY::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -66883,27 +66175,21 @@ - (void)writeAttributeColorPointRXWithValue:(NSNumber * _Nonnull)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ColorControl::Attributes::ColorPointRX::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -66953,27 +66239,21 @@ - (void)writeAttributeColorPointRYWithValue:(NSNumber * _Nonnull)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ColorControl::Attributes::ColorPointRY::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -67023,32 +66303,26 @@ - (void)writeAttributeColorPointRIntensityWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = ColorControl::Attributes::ColorPointRIntensity::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -67098,27 +66372,21 @@ - (void)writeAttributeColorPointGXWithValue:(NSNumber * _Nonnull)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ColorControl::Attributes::ColorPointGX::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -67168,27 +66436,21 @@ - (void)writeAttributeColorPointGYWithValue:(NSNumber * _Nonnull)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ColorControl::Attributes::ColorPointGY::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -67238,32 +66500,26 @@ - (void)writeAttributeColorPointGIntensityWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = ColorControl::Attributes::ColorPointGIntensity::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -67313,27 +66569,21 @@ - (void)writeAttributeColorPointBXWithValue:(NSNumber * _Nonnull)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ColorControl::Attributes::ColorPointBX::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -67383,27 +66633,21 @@ - (void)writeAttributeColorPointBYWithValue:(NSNumber * _Nonnull)value params:(M
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ColorControl::Attributes::ColorPointBY::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -67453,32 +66697,26 @@ - (void)writeAttributeColorPointBIntensityWithValue:(NSNumber * _Nullable)value
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = ColorControl::Attributes::ColorPointBIntensity::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -67924,32 +67162,26 @@ - (void)writeAttributeStartUpColorTemperatureMiredsWithValue:(NSNumber * _Nullab
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedShortValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = ColorControl::Attributes::StartUpColorTemperatureMireds::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedShortValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -70545,27 +69777,21 @@ - (void)writeAttributeMinLevelWithValue:(NSNumber * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = BallastConfiguration::Attributes::MinLevel::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -70615,27 +69841,21 @@ - (void)writeAttributeMaxLevelWithValue:(NSNumber * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = BallastConfiguration::Attributes::MaxLevel::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -70685,32 +69905,26 @@ - (void)writeAttributeIntrinsicBallastFactorWithValue:(NSNumber * _Nullable)valu
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = BallastConfiguration::Attributes::IntrinsicBallastFactor::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = BallastConfiguration::Attributes::IntrinsicBallastFactor::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -70760,32 +69974,26 @@ - (void)writeAttributeBallastFactorAdjustmentWithValue:(NSNumber * _Nullable)val
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = BallastConfiguration::Attributes::BallastFactorAdjustment::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -70871,27 +70079,21 @@ - (void)writeAttributeLampTypeWithValue:(NSString * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsCharSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = BallastConfiguration::Attributes::LampType::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsCharSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -70941,27 +70143,21 @@ - (void)writeAttributeLampManufacturerWithValue:(NSString * _Nonnull)value param
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsCharSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = BallastConfiguration::Attributes::LampManufacturer::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsCharSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -71011,32 +70207,26 @@ - (void)writeAttributeLampRatedHoursWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedIntValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = BallastConfiguration::Attributes::LampRatedHours::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedIntValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -71086,32 +70276,26 @@ - (void)writeAttributeLampBurnHoursWithValue:(NSNumber * _Nullable)value params:
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedIntValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = BallastConfiguration::Attributes::LampBurnHours::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedIntValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -71161,27 +70345,21 @@ - (void)writeAttributeLampAlarmModeWithValue:(NSNumber * _Nonnull)value params:(
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = BallastConfiguration::Attributes::LampAlarmMode::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -71231,32 +70409,26 @@ - (void)writeAttributeLampBurnHoursTripPointWithValue:(NSNumber * _Nullable)valu
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedIntValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = BallastConfiguration::Attributes::LampBurnHoursTripPoint::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedIntValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -76338,27 +75510,21 @@ - (void)writeAttributePIROccupiedToUnoccupiedDelayWithValue:(NSNumber * _Nonnull
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = OccupancySensing::Attributes::PIROccupiedToUnoccupiedDelay::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = OccupancySensing::Attributes::PIROccupiedToUnoccupiedDelay::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -76408,27 +75574,21 @@ - (void)writeAttributePIRUnoccupiedToOccupiedDelayWithValue:(NSNumber * _Nonnull
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = OccupancySensing::Attributes::PIRUnoccupiedToOccupiedDelay::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = OccupancySensing::Attributes::PIRUnoccupiedToOccupiedDelay::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -76478,27 +75638,21 @@ - (void)writeAttributePIRUnoccupiedToOccupiedThresholdWithValue:(NSNumber * _Non
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = OccupancySensing::Attributes::PIRUnoccupiedToOccupiedThreshold::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = OccupancySensing::Attributes::PIRUnoccupiedToOccupiedThreshold::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -76548,27 +75702,21 @@ - (void)writeAttributeUltrasonicOccupiedToUnoccupiedDelayWithValue:(NSNumber * _
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -76618,27 +75766,21 @@ - (void)writeAttributeUltrasonicUnoccupiedToOccupiedDelayWithValue:(NSNumber * _
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -76688,27 +75830,21 @@ - (void)writeAttributeUltrasonicUnoccupiedToOccupiedThresholdWithValue:(NSNumber
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -76758,27 +75894,21 @@ - (void)writeAttributePhysicalContactOccupiedToUnoccupiedDelayWithValue:(NSNumbe
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -76828,27 +75958,21 @@ - (void)writeAttributePhysicalContactUnoccupiedToOccupiedDelayWithValue:(NSNumbe
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -76898,27 +76022,21 @@ - (void)writeAttributePhysicalContactUnoccupiedToOccupiedThresholdWithValue:(NSN
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -88988,27 +88106,21 @@ - (void)writeAttributeSupportedStreamingProtocolsWithValue:(NSNumber * _Nonnull)
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedIntValue;
+        ListFreer listFreer;
+        using TypeInfo = ContentLauncher::Attributes::SupportedStreamingProtocols::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedIntValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -90300,37 +89412,31 @@ - (void)writeAttributeCurrentAppWithValue:(MTRApplicationLauncherClusterApplicat
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0.application.catalogVendorID = value.application.catalogVendorID.unsignedShortValue;
-                nonNullValue_0.application.applicationID = AsCharSpan(value.application.applicationID);
-                if (value.endpoint != nil) {
-                    auto & definedValue_2 = nonNullValue_0.endpoint.Emplace();
-                    definedValue_2 = value.endpoint.unsignedShortValue;
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = ApplicationLauncher::Attributes::CurrentApp::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                              nonNullValue_0.application.catalogVendorID = value.application.catalogVendorID.unsignedShortValue;
+       nonNullValue_0.application.applicationID = AsCharSpan(value.application.applicationID);
+       if (value.endpoint != nil) {
+         auto & definedValue_2 = nonNullValue_0.endpoint.Emplace();
+                 definedValue_2 = value.endpoint.unsignedShortValue;
+  }
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -94555,27 +93661,21 @@ - (void)writeAttributeAverageRmsVoltageMeasurementPeriodWithValue:(NSNumber * _N
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriod::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -94625,27 +93725,21 @@ - (void)writeAttributeAverageRmsUnderVoltageCounterWithValue:(NSNumber * _Nonnul
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounter::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -94695,27 +93789,21 @@ - (void)writeAttributeRmsExtremeOverVoltagePeriodWithValue:(NSNumber * _Nonnull)
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriod::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -94765,27 +93853,21 @@ - (void)writeAttributeRmsExtremeUnderVoltagePeriodWithValue:(NSNumber * _Nonnull
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriod::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -94835,27 +93917,21 @@ - (void)writeAttributeRmsVoltageSagPeriodWithValue:(NSNumber * _Nonnull)value pa
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriod::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -94905,27 +93981,21 @@ - (void)writeAttributeRmsVoltageSwellPeriodWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriod::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -95191,27 +94261,21 @@ - (void)writeAttributeOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value par
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = ElectricalMeasurement::Attributes::OverloadAlarmsMask::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -95333,27 +94397,21 @@ - (void)writeAttributeAcOverloadAlarmsMaskWithValue:(NSNumber * _Nonnull)value p
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = ElectricalMeasurement::Attributes::AcOverloadAlarmsMask::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -102876,27 +101934,21 @@ - (void)writeAttributeBooleanWithValue:(NSNumber * _Nonnull)value params:(MTRWri
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Boolean::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Boolean::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -102946,27 +101998,21 @@ - (void)writeAttributeBitmap8WithValue:(NSNumber * _Nonnull)value params:(MTRWri
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Bitmap8::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Bitmap8::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103016,27 +102062,21 @@ - (void)writeAttributeBitmap16WithValue:(NSNumber * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Bitmap16::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Bitmap16::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103086,27 +102126,21 @@ - (void)writeAttributeBitmap32WithValue:(NSNumber * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Bitmap32::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedIntValue);
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Bitmap32::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedIntValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103156,27 +102190,21 @@ - (void)writeAttributeBitmap64WithValue:(NSNumber * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Bitmap64::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedLongLongValue);
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Bitmap64::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedLongLongValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103226,27 +102254,21 @@ - (void)writeAttributeInt8uWithValue:(NSNumber * _Nonnull)value params:(MTRWrite
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int8u::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int8u::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103296,27 +102318,21 @@ - (void)writeAttributeInt16uWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int16u::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int16u::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103366,27 +102382,21 @@ - (void)writeAttributeInt24uWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int24u::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedIntValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int24u::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedIntValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103436,27 +102446,21 @@ - (void)writeAttributeInt32uWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int32u::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedIntValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int32u::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedIntValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103506,27 +102510,21 @@ - (void)writeAttributeInt40uWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int40u::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedLongLongValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int40u::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedLongLongValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103576,27 +102574,21 @@ - (void)writeAttributeInt48uWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int48u::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedLongLongValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int48u::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedLongLongValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103646,27 +102638,21 @@ - (void)writeAttributeInt56uWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int56u::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedLongLongValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int56u::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedLongLongValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103716,27 +102702,21 @@ - (void)writeAttributeInt64uWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int64u::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedLongLongValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int64u::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedLongLongValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103786,27 +102766,21 @@ - (void)writeAttributeInt8sWithValue:(NSNumber * _Nonnull)value params:(MTRWrite
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int8s::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.charValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int8s::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.charValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103856,27 +102830,21 @@ - (void)writeAttributeInt16sWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int16s::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.shortValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int16s::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.shortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103926,27 +102894,21 @@ - (void)writeAttributeInt24sWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int24s::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.intValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int24s::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.intValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -103996,27 +102958,21 @@ - (void)writeAttributeInt32sWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int32s::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.intValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int32s::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.intValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -104066,27 +103022,21 @@ - (void)writeAttributeInt40sWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int40s::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.longLongValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int40s::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.longLongValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -104136,27 +103086,21 @@ - (void)writeAttributeInt48sWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int48s::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.longLongValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int48s::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.longLongValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -104206,27 +103150,21 @@ - (void)writeAttributeInt56sWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int56s::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.longLongValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int56s::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.longLongValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -104276,27 +103214,21 @@ - (void)writeAttributeInt64sWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Int64s::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.longLongValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Int64s::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.longLongValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -104346,27 +103278,21 @@ - (void)writeAttributeEnum8WithValue:(NSNumber * _Nonnull)value params:(MTRWrite
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Enum8::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Enum8::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -104416,27 +103342,21 @@ - (void)writeAttributeEnum16WithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Enum16::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Enum16::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -104486,27 +103406,21 @@ - (void)writeAttributeFloatSingleWithValue:(NSNumber * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::FloatSingle::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.floatValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::FloatSingle::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.floatValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -104556,27 +103470,21 @@ - (void)writeAttributeFloatDoubleWithValue:(NSNumber * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::FloatDouble::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.doubleValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::FloatDouble::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.doubleValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -104626,27 +103534,21 @@ - (void)writeAttributeOctetStringWithValue:(NSData * _Nonnull)value params:(MTRW
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::OctetString::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsByteSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::OctetString::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsByteSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -104696,48 +103598,42 @@ - (void)writeAttributeListInt8uWithValue:(NSArray * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::ListInt8u::TypeInfo;
-            TypeInfo::Type cppValue;
-            {
-                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (value.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
-                        if (![value[i_0] isKindOfClass:[NSNumber class]]) {
-                            // Wrong kind of value.
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        auto element_0 = (NSNumber *) value[i_0];
-                        listHolder_0->mList[i_0] = element_0.unsignedCharValue;
-                    }
-                    cppValue = ListType_0(listHolder_0->mList, value.count);
-                } else {
-                    cppValue = ListType_0();
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::ListInt8u::TypeInfo;
+        TypeInfo::Type cppValue;
+          {
+            using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
+            using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+            if (value.count != 0) {
+              auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
+              if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
+                return CHIP_ERROR_INVALID_ARGUMENT;
+              }
+              listFreer.add(listHolder_0);
+              for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
+                if ( ! [value[i_0] isKindOfClass: [NSNumber class]] ) {
+                  // Wrong kind of value.
+                  return CHIP_ERROR_INVALID_ARGUMENT;
                 }
+                auto element_0 = (NSNumber *)value[i_0];
+                        listHolder_0->mList[i_0] = element_0.unsignedCharValue;
+      }
+              cppValue = ListType_0(listHolder_0->mList, value.count);
+            } else {
+              cppValue = ListType_0();
             }
+          }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -104787,48 +103683,42 @@ - (void)writeAttributeListOctetStringWithValue:(NSArray * _Nonnull)value params:
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::ListOctetString::TypeInfo;
-            TypeInfo::Type cppValue;
-            {
-                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (value.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
-                        if (![value[i_0] isKindOfClass:[NSData class]]) {
-                            // Wrong kind of value.
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        auto element_0 = (NSData *) value[i_0];
-                        listHolder_0->mList[i_0] = AsByteSpan(element_0);
-                    }
-                    cppValue = ListType_0(listHolder_0->mList, value.count);
-                } else {
-                    cppValue = ListType_0();
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::ListOctetString::TypeInfo;
+        TypeInfo::Type cppValue;
+          {
+            using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
+            using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+            if (value.count != 0) {
+              auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
+              if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
+                return CHIP_ERROR_INVALID_ARGUMENT;
+              }
+              listFreer.add(listHolder_0);
+              for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
+                if ( ! [value[i_0] isKindOfClass: [NSData class]] ) {
+                  // Wrong kind of value.
+                  return CHIP_ERROR_INVALID_ARGUMENT;
                 }
+                auto element_0 = (NSData *)value[i_0];
+                  listHolder_0->mList[i_0] = AsByteSpan(element_0);
+              }
+              cppValue = ListType_0(listHolder_0->mList, value.count);
+            } else {
+              cppValue = ListType_0();
             }
+          }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -104878,49 +103768,43 @@ - (void)writeAttributeListStructOctetStringWithValue:(NSArray * _Nonnull)value p
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::ListStructOctetString::TypeInfo;
-            TypeInfo::Type cppValue;
-            {
-                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (value.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
-                        if (![value[i_0] isKindOfClass:[MTRUnitTestingClusterTestListStructOctet class]]) {
-                            // Wrong kind of value.
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        auto element_0 = (MTRUnitTestingClusterTestListStructOctet *) value[i_0];
-                        listHolder_0->mList[i_0].member1 = element_0.member1.unsignedLongLongValue;
-                        listHolder_0->mList[i_0].member2 = AsByteSpan(element_0.member2);
-                    }
-                    cppValue = ListType_0(listHolder_0->mList, value.count);
-                } else {
-                    cppValue = ListType_0();
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::ListStructOctetString::TypeInfo;
+        TypeInfo::Type cppValue;
+          {
+            using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
+            using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+            if (value.count != 0) {
+              auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
+              if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
+                return CHIP_ERROR_INVALID_ARGUMENT;
+              }
+              listFreer.add(listHolder_0);
+              for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
+                if ( ! [value[i_0] isKindOfClass: [MTRUnitTestingClusterTestListStructOctet class]] ) {
+                  // Wrong kind of value.
+                  return CHIP_ERROR_INVALID_ARGUMENT;
                 }
+                auto element_0 = (MTRUnitTestingClusterTestListStructOctet *)value[i_0];
+                             listHolder_0->mList[i_0].member1 = element_0.member1.unsignedLongLongValue;
+       listHolder_0->mList[i_0].member2 = AsByteSpan(element_0.member2);
+      }
+              cppValue = ListType_0(listHolder_0->mList, value.count);
+            } else {
+              cppValue = ListType_0();
             }
+          }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -104970,27 +103854,21 @@ - (void)writeAttributeLongOctetStringWithValue:(NSData * _Nonnull)value params:(
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::LongOctetString::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsByteSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::LongOctetString::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsByteSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -105040,27 +103918,21 @@ - (void)writeAttributeCharStringWithValue:(NSString * _Nonnull)value params:(MTR
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::CharString::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsCharSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::CharString::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsCharSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -105110,27 +103982,21 @@ - (void)writeAttributeLongCharStringWithValue:(NSString * _Nonnull)value params:
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::LongCharString::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = AsCharSpan(value);
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::LongCharString::TypeInfo;
+        TypeInfo::Type cppValue;
+          cppValue = AsCharSpan(value);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -105180,27 +104046,21 @@ - (void)writeAttributeEpochUsWithValue:(NSNumber * _Nonnull)value params:(MTRWri
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::EpochUs::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedLongLongValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::EpochUs::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedLongLongValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -105250,27 +104110,21 @@ - (void)writeAttributeEpochSWithValue:(NSNumber * _Nonnull)value params:(MTRWrit
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::EpochS::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedIntValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::EpochS::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedIntValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -105320,27 +104174,21 @@ - (void)writeAttributeVendorIdWithValue:(NSNumber * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::VendorId::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::VendorId::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -105390,207 +104238,201 @@ - (void)writeAttributeListNullablesAndOptionalsStructWithValue:(NSArray * _Nonnu
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
-            TypeInfo::Type cppValue;
-            {
-                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (value.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
-                        if (![value[i_0] isKindOfClass:[MTRUnitTestingClusterNullablesAndOptionalsStruct class]]) {
-                            // Wrong kind of value.
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        auto element_0 = (MTRUnitTestingClusterNullablesAndOptionalsStruct *) value[i_0];
-                        if (element_0.nullableInt == nil) {
-                            listHolder_0->mList[i_0].nullableInt.SetNull();
-                        } else {
-                            auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableInt.SetNonNull();
-                            nonNullValue_2 = element_0.nullableInt.unsignedShortValue;
-                        }
-                        if (element_0.optionalInt != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].optionalInt.Emplace();
-                            definedValue_2 = element_0.optionalInt.unsignedShortValue;
-                        }
-                        if (element_0.nullableOptionalInt != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalInt.Emplace();
-                            if (element_0.nullableOptionalInt == nil) {
-                                definedValue_2.SetNull();
-                            } else {
-                                auto & nonNullValue_3 = definedValue_2.SetNonNull();
-                                nonNullValue_3 = element_0.nullableOptionalInt.unsignedShortValue;
-                            }
-                        }
-                        if (element_0.nullableString == nil) {
-                            listHolder_0->mList[i_0].nullableString.SetNull();
-                        } else {
-                            auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableString.SetNonNull();
-                            nonNullValue_2 = AsCharSpan(element_0.nullableString);
-                        }
-                        if (element_0.optionalString != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].optionalString.Emplace();
-                            definedValue_2 = AsCharSpan(element_0.optionalString);
-                        }
-                        if (element_0.nullableOptionalString != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalString.Emplace();
-                            if (element_0.nullableOptionalString == nil) {
-                                definedValue_2.SetNull();
-                            } else {
-                                auto & nonNullValue_3 = definedValue_2.SetNonNull();
-                                nonNullValue_3 = AsCharSpan(element_0.nullableOptionalString);
-                            }
-                        }
-                        if (element_0.nullableStruct == nil) {
-                            listHolder_0->mList[i_0].nullableStruct.SetNull();
-                        } else {
-                            auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableStruct.SetNonNull();
-                            nonNullValue_2.a = element_0.nullableStruct.a.unsignedCharValue;
-                            nonNullValue_2.b = element_0.nullableStruct.b.boolValue;
-                            nonNullValue_2.c = static_cast<std::remove_reference_t<decltype(nonNullValue_2.c)>>(element_0.nullableStruct.c.unsignedCharValue);
-                            nonNullValue_2.d = AsByteSpan(element_0.nullableStruct.d);
-                            nonNullValue_2.e = AsCharSpan(element_0.nullableStruct.e);
-                            nonNullValue_2.f = static_cast<std::remove_reference_t<decltype(nonNullValue_2.f)>>(element_0.nullableStruct.f.unsignedCharValue);
-                            nonNullValue_2.g = element_0.nullableStruct.g.floatValue;
-                            nonNullValue_2.h = element_0.nullableStruct.h.doubleValue;
-                        }
-                        if (element_0.optionalStruct != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].optionalStruct.Emplace();
-                            definedValue_2.a = element_0.optionalStruct.a.unsignedCharValue;
-                            definedValue_2.b = element_0.optionalStruct.b.boolValue;
-                            definedValue_2.c = static_cast<std::remove_reference_t<decltype(definedValue_2.c)>>(element_0.optionalStruct.c.unsignedCharValue);
-                            definedValue_2.d = AsByteSpan(element_0.optionalStruct.d);
-                            definedValue_2.e = AsCharSpan(element_0.optionalStruct.e);
-                            definedValue_2.f = static_cast<std::remove_reference_t<decltype(definedValue_2.f)>>(element_0.optionalStruct.f.unsignedCharValue);
-                            definedValue_2.g = element_0.optionalStruct.g.floatValue;
-                            definedValue_2.h = element_0.optionalStruct.h.doubleValue;
-                        }
-                        if (element_0.nullableOptionalStruct != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalStruct.Emplace();
-                            if (element_0.nullableOptionalStruct == nil) {
-                                definedValue_2.SetNull();
-                            } else {
-                                auto & nonNullValue_3 = definedValue_2.SetNonNull();
-                                nonNullValue_3.a = element_0.nullableOptionalStruct.a.unsignedCharValue;
-                                nonNullValue_3.b = element_0.nullableOptionalStruct.b.boolValue;
-                                nonNullValue_3.c = static_cast<std::remove_reference_t<decltype(nonNullValue_3.c)>>(element_0.nullableOptionalStruct.c.unsignedCharValue);
-                                nonNullValue_3.d = AsByteSpan(element_0.nullableOptionalStruct.d);
-                                nonNullValue_3.e = AsCharSpan(element_0.nullableOptionalStruct.e);
-                                nonNullValue_3.f = static_cast<std::remove_reference_t<decltype(nonNullValue_3.f)>>(element_0.nullableOptionalStruct.f.unsignedCharValue);
-                                nonNullValue_3.g = element_0.nullableOptionalStruct.g.floatValue;
-                                nonNullValue_3.h = element_0.nullableOptionalStruct.h.doubleValue;
-                            }
-                        }
-                        if (element_0.nullableList == nil) {
-                            listHolder_0->mList[i_0].nullableList.SetNull();
-                        } else {
-                            auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableList.SetNonNull();
-                            {
-                                using ListType_3 = std::remove_reference_t<decltype(nonNullValue_2)>;
-                                using ListMemberType_3 = ListMemberTypeGetter<ListType_3>::Type;
-                                if (element_0.nullableList.count != 0) {
-                                    auto * listHolder_3 = new ListHolder<ListMemberType_3>(element_0.nullableList.count);
-                                    if (listHolder_3 == nullptr || listHolder_3->mList == nullptr) {
-                                        return CHIP_ERROR_INVALID_ARGUMENT;
-                                    }
-                                    listFreer.add(listHolder_3);
-                                    for (size_t i_3 = 0; i_3 < element_0.nullableList.count; ++i_3) {
-                                        if (![element_0.nullableList[i_3] isKindOfClass:[NSNumber class]]) {
-                                            // Wrong kind of value.
-                                            return CHIP_ERROR_INVALID_ARGUMENT;
-                                        }
-                                        auto element_3 = (NSNumber *) element_0.nullableList[i_3];
-                                        listHolder_3->mList[i_3] = static_cast<std::remove_reference_t<decltype(listHolder_3->mList[i_3])>>(element_3.unsignedCharValue);
-                                    }
-                                    nonNullValue_2 = ListType_3(listHolder_3->mList, element_0.nullableList.count);
-                                } else {
-                                    nonNullValue_2 = ListType_3();
-                                }
-                            }
-                        }
-                        if (element_0.optionalList != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].optionalList.Emplace();
-                            {
-                                using ListType_3 = std::remove_reference_t<decltype(definedValue_2)>;
-                                using ListMemberType_3 = ListMemberTypeGetter<ListType_3>::Type;
-                                if (element_0.optionalList.count != 0) {
-                                    auto * listHolder_3 = new ListHolder<ListMemberType_3>(element_0.optionalList.count);
-                                    if (listHolder_3 == nullptr || listHolder_3->mList == nullptr) {
-                                        return CHIP_ERROR_INVALID_ARGUMENT;
-                                    }
-                                    listFreer.add(listHolder_3);
-                                    for (size_t i_3 = 0; i_3 < element_0.optionalList.count; ++i_3) {
-                                        if (![element_0.optionalList[i_3] isKindOfClass:[NSNumber class]]) {
-                                            // Wrong kind of value.
-                                            return CHIP_ERROR_INVALID_ARGUMENT;
-                                        }
-                                        auto element_3 = (NSNumber *) element_0.optionalList[i_3];
-                                        listHolder_3->mList[i_3] = static_cast<std::remove_reference_t<decltype(listHolder_3->mList[i_3])>>(element_3.unsignedCharValue);
-                                    }
-                                    definedValue_2 = ListType_3(listHolder_3->mList, element_0.optionalList.count);
-                                } else {
-                                    definedValue_2 = ListType_3();
-                                }
-                            }
-                        }
-                        if (element_0.nullableOptionalList != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalList.Emplace();
-                            if (element_0.nullableOptionalList == nil) {
-                                definedValue_2.SetNull();
-                            } else {
-                                auto & nonNullValue_3 = definedValue_2.SetNonNull();
-                                {
-                                    using ListType_4 = std::remove_reference_t<decltype(nonNullValue_3)>;
-                                    using ListMemberType_4 = ListMemberTypeGetter<ListType_4>::Type;
-                                    if (element_0.nullableOptionalList.count != 0) {
-                                        auto * listHolder_4 = new ListHolder<ListMemberType_4>(element_0.nullableOptionalList.count);
-                                        if (listHolder_4 == nullptr || listHolder_4->mList == nullptr) {
-                                            return CHIP_ERROR_INVALID_ARGUMENT;
-                                        }
-                                        listFreer.add(listHolder_4);
-                                        for (size_t i_4 = 0; i_4 < element_0.nullableOptionalList.count; ++i_4) {
-                                            if (![element_0.nullableOptionalList[i_4] isKindOfClass:[NSNumber class]]) {
-                                                // Wrong kind of value.
-                                                return CHIP_ERROR_INVALID_ARGUMENT;
-                                            }
-                                            auto element_4 = (NSNumber *) element_0.nullableOptionalList[i_4];
-                                            listHolder_4->mList[i_4] = static_cast<std::remove_reference_t<decltype(listHolder_4->mList[i_4])>>(element_4.unsignedCharValue);
-                                        }
-                                        nonNullValue_3 = ListType_4(listHolder_4->mList, element_0.nullableOptionalList.count);
-                                    } else {
-                                        nonNullValue_3 = ListType_4();
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    cppValue = ListType_0(listHolder_0->mList, value.count);
-                } else {
-                    cppValue = ListType_0();
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::ListNullablesAndOptionalsStruct::TypeInfo;
+        TypeInfo::Type cppValue;
+          {
+            using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
+            using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+            if (value.count != 0) {
+              auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
+              if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
+                return CHIP_ERROR_INVALID_ARGUMENT;
+              }
+              listFreer.add(listHolder_0);
+              for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
+                if ( ! [value[i_0] isKindOfClass: [MTRUnitTestingClusterNullablesAndOptionalsStruct class]] ) {
+                  // Wrong kind of value.
+                  return CHIP_ERROR_INVALID_ARGUMENT;
                 }
+                auto element_0 = (MTRUnitTestingClusterNullablesAndOptionalsStruct *)value[i_0];
+                       if (element_0.nullableInt == nil) {
+         listHolder_0->mList[i_0].nullableInt.SetNull();
+       } else {
+         auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableInt.SetNonNull();
+                 nonNullValue_2 = element_0.nullableInt.unsignedShortValue;
+  }
+       if (element_0.optionalInt != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].optionalInt.Emplace();
+                 definedValue_2 = element_0.optionalInt.unsignedShortValue;
+  }
+       if (element_0.nullableOptionalInt != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalInt.Emplace();
+           if (element_0.nullableOptionalInt == nil) {
+             definedValue_2.SetNull();
+           } else {
+             auto & nonNullValue_3 = definedValue_2.SetNonNull();
+                     nonNullValue_3 = element_0.nullableOptionalInt.unsignedShortValue;
+  }
+       }
+       if (element_0.nullableString == nil) {
+         listHolder_0->mList[i_0].nullableString.SetNull();
+       } else {
+         auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableString.SetNonNull();
+           nonNullValue_2 = AsCharSpan(element_0.nullableString);
+       }
+       if (element_0.optionalString != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].optionalString.Emplace();
+           definedValue_2 = AsCharSpan(element_0.optionalString);
+       }
+       if (element_0.nullableOptionalString != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalString.Emplace();
+           if (element_0.nullableOptionalString == nil) {
+             definedValue_2.SetNull();
+           } else {
+             auto & nonNullValue_3 = definedValue_2.SetNonNull();
+               nonNullValue_3 = AsCharSpan(element_0.nullableOptionalString);
+           }
+       }
+       if (element_0.nullableStruct == nil) {
+         listHolder_0->mList[i_0].nullableStruct.SetNull();
+       } else {
+         auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableStruct.SetNonNull();
+                      nonNullValue_2.a = element_0.nullableStruct.a.unsignedCharValue;
+             nonNullValue_2.b = element_0.nullableStruct.b.boolValue;
+           nonNullValue_2.c = static_cast<std::remove_reference_t<decltype(nonNullValue_2.c)>>(element_0.nullableStruct.c.unsignedCharValue);
+       nonNullValue_2.d = AsByteSpan(element_0.nullableStruct.d);
+       nonNullValue_2.e = AsCharSpan(element_0.nullableStruct.e);
+             nonNullValue_2.f = static_cast<std::remove_reference_t<decltype(nonNullValue_2.f)>>(element_0.nullableStruct.f.unsignedCharValue);
+             nonNullValue_2.g = element_0.nullableStruct.g.floatValue;
+             nonNullValue_2.h = element_0.nullableStruct.h.doubleValue;
+  }
+       if (element_0.optionalStruct != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].optionalStruct.Emplace();
+                      definedValue_2.a = element_0.optionalStruct.a.unsignedCharValue;
+             definedValue_2.b = element_0.optionalStruct.b.boolValue;
+           definedValue_2.c = static_cast<std::remove_reference_t<decltype(definedValue_2.c)>>(element_0.optionalStruct.c.unsignedCharValue);
+       definedValue_2.d = AsByteSpan(element_0.optionalStruct.d);
+       definedValue_2.e = AsCharSpan(element_0.optionalStruct.e);
+             definedValue_2.f = static_cast<std::remove_reference_t<decltype(definedValue_2.f)>>(element_0.optionalStruct.f.unsignedCharValue);
+             definedValue_2.g = element_0.optionalStruct.g.floatValue;
+             definedValue_2.h = element_0.optionalStruct.h.doubleValue;
+  }
+       if (element_0.nullableOptionalStruct != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalStruct.Emplace();
+           if (element_0.nullableOptionalStruct == nil) {
+             definedValue_2.SetNull();
+           } else {
+             auto & nonNullValue_3 = definedValue_2.SetNonNull();
+                          nonNullValue_3.a = element_0.nullableOptionalStruct.a.unsignedCharValue;
+             nonNullValue_3.b = element_0.nullableOptionalStruct.b.boolValue;
+           nonNullValue_3.c = static_cast<std::remove_reference_t<decltype(nonNullValue_3.c)>>(element_0.nullableOptionalStruct.c.unsignedCharValue);
+       nonNullValue_3.d = AsByteSpan(element_0.nullableOptionalStruct.d);
+       nonNullValue_3.e = AsCharSpan(element_0.nullableOptionalStruct.e);
+             nonNullValue_3.f = static_cast<std::remove_reference_t<decltype(nonNullValue_3.f)>>(element_0.nullableOptionalStruct.f.unsignedCharValue);
+             nonNullValue_3.g = element_0.nullableOptionalStruct.g.floatValue;
+             nonNullValue_3.h = element_0.nullableOptionalStruct.h.doubleValue;
+  }
+       }
+       if (element_0.nullableList == nil) {
+         listHolder_0->mList[i_0].nullableList.SetNull();
+       } else {
+         auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableList.SetNonNull();
+           {
+             using ListType_3 = std::remove_reference_t<decltype(nonNullValue_2)>;
+             using ListMemberType_3 = ListMemberTypeGetter<ListType_3>::Type;
+             if (element_0.nullableList.count != 0) {
+               auto * listHolder_3 = new ListHolder<ListMemberType_3>(element_0.nullableList.count);
+               if (listHolder_3 == nullptr || listHolder_3->mList == nullptr) {
+                 return CHIP_ERROR_INVALID_ARGUMENT;
+               }
+               listFreer.add(listHolder_3);
+               for (size_t i_3 = 0; i_3 < element_0.nullableList.count; ++i_3) {
+                 if ( ! [element_0.nullableList[i_3] isKindOfClass: [NSNumber class]] ) {
+                   // Wrong kind of value.
+                   return CHIP_ERROR_INVALID_ARGUMENT;
+                 }
+                 auto element_3 = (NSNumber *)element_0.nullableList[i_3];
+                       listHolder_3->mList[i_3] = static_cast<std::remove_reference_t<decltype(listHolder_3->mList[i_3])>>(element_3.unsignedCharValue);
+      }
+               nonNullValue_2 = ListType_3(listHolder_3->mList, element_0.nullableList.count);
+             } else {
+               nonNullValue_2 = ListType_3();
+             }
+           }
+       }
+       if (element_0.optionalList != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].optionalList.Emplace();
+           {
+             using ListType_3 = std::remove_reference_t<decltype(definedValue_2)>;
+             using ListMemberType_3 = ListMemberTypeGetter<ListType_3>::Type;
+             if (element_0.optionalList.count != 0) {
+               auto * listHolder_3 = new ListHolder<ListMemberType_3>(element_0.optionalList.count);
+               if (listHolder_3 == nullptr || listHolder_3->mList == nullptr) {
+                 return CHIP_ERROR_INVALID_ARGUMENT;
+               }
+               listFreer.add(listHolder_3);
+               for (size_t i_3 = 0; i_3 < element_0.optionalList.count; ++i_3) {
+                 if ( ! [element_0.optionalList[i_3] isKindOfClass: [NSNumber class]] ) {
+                   // Wrong kind of value.
+                   return CHIP_ERROR_INVALID_ARGUMENT;
+                 }
+                 auto element_3 = (NSNumber *)element_0.optionalList[i_3];
+                       listHolder_3->mList[i_3] = static_cast<std::remove_reference_t<decltype(listHolder_3->mList[i_3])>>(element_3.unsignedCharValue);
+      }
+               definedValue_2 = ListType_3(listHolder_3->mList, element_0.optionalList.count);
+             } else {
+               definedValue_2 = ListType_3();
+             }
+           }
+       }
+       if (element_0.nullableOptionalList != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalList.Emplace();
+           if (element_0.nullableOptionalList == nil) {
+             definedValue_2.SetNull();
+           } else {
+             auto & nonNullValue_3 = definedValue_2.SetNonNull();
+               {
+                 using ListType_4 = std::remove_reference_t<decltype(nonNullValue_3)>;
+                 using ListMemberType_4 = ListMemberTypeGetter<ListType_4>::Type;
+                 if (element_0.nullableOptionalList.count != 0) {
+                   auto * listHolder_4 = new ListHolder<ListMemberType_4>(element_0.nullableOptionalList.count);
+                   if (listHolder_4 == nullptr || listHolder_4->mList == nullptr) {
+                     return CHIP_ERROR_INVALID_ARGUMENT;
+                   }
+                   listFreer.add(listHolder_4);
+                   for (size_t i_4 = 0; i_4 < element_0.nullableOptionalList.count; ++i_4) {
+                     if ( ! [element_0.nullableOptionalList[i_4] isKindOfClass: [NSNumber class]] ) {
+                       // Wrong kind of value.
+                       return CHIP_ERROR_INVALID_ARGUMENT;
+                     }
+                     auto element_4 = (NSNumber *)element_0.nullableOptionalList[i_4];
+                           listHolder_4->mList[i_4] = static_cast<std::remove_reference_t<decltype(listHolder_4->mList[i_4])>>(element_4.unsignedCharValue);
+      }
+                   nonNullValue_3 = ListType_4(listHolder_4->mList, element_0.nullableOptionalList.count);
+                 } else {
+                   nonNullValue_3 = ListType_4();
+                 }
+               }
+           }
+       }
+      }
+              cppValue = ListType_0(listHolder_0->mList, value.count);
+            } else {
+              cppValue = ListType_0();
             }
+          }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -105640,27 +104482,21 @@ - (void)writeAttributeEnumAttrWithValue:(NSNumber * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::EnumAttr::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::EnumAttr::TypeInfo;
+        TypeInfo::Type cppValue;
+              cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -105710,34 +104546,28 @@ - (void)writeAttributeStructAttrWithValue:(MTRUnitTestingClusterSimpleStruct * _
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::StructAttr::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue.a = value.a.unsignedCharValue;
-            cppValue.b = value.b.boolValue;
-            cppValue.c = static_cast<std::remove_reference_t<decltype(cppValue.c)>>(value.c.unsignedCharValue);
-            cppValue.d = AsByteSpan(value.d);
-            cppValue.e = AsCharSpan(value.e);
-            cppValue.f = static_cast<std::remove_reference_t<decltype(cppValue.f)>>(value.f.unsignedCharValue);
-            cppValue.g = value.g.floatValue;
-            cppValue.h = value.h.doubleValue;
-
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::StructAttr::TypeInfo;
+        TypeInfo::Type cppValue;
+                     cppValue.a = value.a.unsignedCharValue;
+             cppValue.b = value.b.boolValue;
+           cppValue.c = static_cast<std::remove_reference_t<decltype(cppValue.c)>>(value.c.unsignedCharValue);
+       cppValue.d = AsByteSpan(value.d);
+       cppValue.e = AsCharSpan(value.e);
+             cppValue.f = static_cast<std::remove_reference_t<decltype(cppValue.f)>>(value.f.unsignedCharValue);
+             cppValue.g = value.g.floatValue;
+             cppValue.h = value.h.doubleValue;
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -105787,27 +104617,21 @@ - (void)writeAttributeRangeRestrictedInt8uWithValue:(NSNumber * _Nonnull)value p
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt8u::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt8u::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -105857,27 +104681,21 @@ - (void)writeAttributeRangeRestrictedInt8sWithValue:(NSNumber * _Nonnull)value p
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt8s::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.charValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt8s::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.charValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -105927,27 +104745,21 @@ - (void)writeAttributeRangeRestrictedInt16uWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt16u::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedShortValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt16u::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedShortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -105997,27 +104809,21 @@ - (void)writeAttributeRangeRestrictedInt16sWithValue:(NSNumber * _Nonnull)value
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt16s::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.shortValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::RangeRestrictedInt16s::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.shortValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -106067,48 +104873,42 @@ - (void)writeAttributeListLongOctetStringWithValue:(NSArray * _Nonnull)value par
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::ListLongOctetString::TypeInfo;
-            TypeInfo::Type cppValue;
-            {
-                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (value.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
-                        if (![value[i_0] isKindOfClass:[NSData class]]) {
-                            // Wrong kind of value.
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        auto element_0 = (NSData *) value[i_0];
-                        listHolder_0->mList[i_0] = AsByteSpan(element_0);
-                    }
-                    cppValue = ListType_0(listHolder_0->mList, value.count);
-                } else {
-                    cppValue = ListType_0();
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::ListLongOctetString::TypeInfo;
+        TypeInfo::Type cppValue;
+          {
+            using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
+            using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+            if (value.count != 0) {
+              auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
+              if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
+                return CHIP_ERROR_INVALID_ARGUMENT;
+              }
+              listFreer.add(listHolder_0);
+              for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
+                if ( ! [value[i_0] isKindOfClass: [NSData class]] ) {
+                  // Wrong kind of value.
+                  return CHIP_ERROR_INVALID_ARGUMENT;
                 }
+                auto element_0 = (NSData *)value[i_0];
+                  listHolder_0->mList[i_0] = AsByteSpan(element_0);
+              }
+              cppValue = ListType_0(listHolder_0->mList, value.count);
+            } else {
+              cppValue = ListType_0();
             }
+          }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -106158,99 +104958,93 @@ - (void)writeAttributeListFabricScopedWithValue:(NSArray * _Nonnull)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::ListFabricScoped::TypeInfo;
-            TypeInfo::Type cppValue;
-            {
-                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
-                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
-                if (value.count != 0) {
-                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
-                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
-                        return CHIP_ERROR_INVALID_ARGUMENT;
-                    }
-                    listFreer.add(listHolder_0);
-                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
-                        if (![value[i_0] isKindOfClass:[MTRUnitTestingClusterTestFabricScoped class]]) {
-                            // Wrong kind of value.
-                            return CHIP_ERROR_INVALID_ARGUMENT;
-                        }
-                        auto element_0 = (MTRUnitTestingClusterTestFabricScoped *) value[i_0];
-                        listHolder_0->mList[i_0].fabricSensitiveInt8u = element_0.fabricSensitiveInt8u.unsignedCharValue;
-                        if (element_0.optionalFabricSensitiveInt8u != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].optionalFabricSensitiveInt8u.Emplace();
-                            definedValue_2 = element_0.optionalFabricSensitiveInt8u.unsignedCharValue;
-                        }
-                        if (element_0.nullableFabricSensitiveInt8u == nil) {
-                            listHolder_0->mList[i_0].nullableFabricSensitiveInt8u.SetNull();
-                        } else {
-                            auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableFabricSensitiveInt8u.SetNonNull();
-                            nonNullValue_2 = element_0.nullableFabricSensitiveInt8u.unsignedCharValue;
-                        }
-                        if (element_0.nullableOptionalFabricSensitiveInt8u != nil) {
-                            auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalFabricSensitiveInt8u.Emplace();
-                            if (element_0.nullableOptionalFabricSensitiveInt8u == nil) {
-                                definedValue_2.SetNull();
-                            } else {
-                                auto & nonNullValue_3 = definedValue_2.SetNonNull();
-                                nonNullValue_3 = element_0.nullableOptionalFabricSensitiveInt8u.unsignedCharValue;
-                            }
-                        }
-                        listHolder_0->mList[i_0].fabricSensitiveCharString = AsCharSpan(element_0.fabricSensitiveCharString);
-                        listHolder_0->mList[i_0].fabricSensitiveStruct.a = element_0.fabricSensitiveStruct.a.unsignedCharValue;
-                        listHolder_0->mList[i_0].fabricSensitiveStruct.b = element_0.fabricSensitiveStruct.b.boolValue;
-                        listHolder_0->mList[i_0].fabricSensitiveStruct.c = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].fabricSensitiveStruct.c)>>(element_0.fabricSensitiveStruct.c.unsignedCharValue);
-                        listHolder_0->mList[i_0].fabricSensitiveStruct.d = AsByteSpan(element_0.fabricSensitiveStruct.d);
-                        listHolder_0->mList[i_0].fabricSensitiveStruct.e = AsCharSpan(element_0.fabricSensitiveStruct.e);
-                        listHolder_0->mList[i_0].fabricSensitiveStruct.f = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].fabricSensitiveStruct.f)>>(element_0.fabricSensitiveStruct.f.unsignedCharValue);
-                        listHolder_0->mList[i_0].fabricSensitiveStruct.g = element_0.fabricSensitiveStruct.g.floatValue;
-                        listHolder_0->mList[i_0].fabricSensitiveStruct.h = element_0.fabricSensitiveStruct.h.doubleValue;
-                        {
-                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].fabricSensitiveInt8uList)>;
-                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
-                            if (element_0.fabricSensitiveInt8uList.count != 0) {
-                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.fabricSensitiveInt8uList.count);
-                                if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
-                                    return CHIP_ERROR_INVALID_ARGUMENT;
-                                }
-                                listFreer.add(listHolder_2);
-                                for (size_t i_2 = 0; i_2 < element_0.fabricSensitiveInt8uList.count; ++i_2) {
-                                    if (![element_0.fabricSensitiveInt8uList[i_2] isKindOfClass:[NSNumber class]]) {
-                                        // Wrong kind of value.
-                                        return CHIP_ERROR_INVALID_ARGUMENT;
-                                    }
-                                    auto element_2 = (NSNumber *) element_0.fabricSensitiveInt8uList[i_2];
-                                    listHolder_2->mList[i_2] = element_2.unsignedCharValue;
-                                }
-                                listHolder_0->mList[i_0].fabricSensitiveInt8uList = ListType_2(listHolder_2->mList, element_0.fabricSensitiveInt8uList.count);
-                            } else {
-                                listHolder_0->mList[i_0].fabricSensitiveInt8uList = ListType_2();
-                            }
-                        }
-                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
-                    }
-                    cppValue = ListType_0(listHolder_0->mList, value.count);
-                } else {
-                    cppValue = ListType_0();
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::ListFabricScoped::TypeInfo;
+        TypeInfo::Type cppValue;
+          {
+            using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
+            using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
+            if (value.count != 0) {
+              auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
+              if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
+                return CHIP_ERROR_INVALID_ARGUMENT;
+              }
+              listFreer.add(listHolder_0);
+              for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
+                if ( ! [value[i_0] isKindOfClass: [MTRUnitTestingClusterTestFabricScoped class]] ) {
+                  // Wrong kind of value.
+                  return CHIP_ERROR_INVALID_ARGUMENT;
                 }
+                auto element_0 = (MTRUnitTestingClusterTestFabricScoped *)value[i_0];
+                             listHolder_0->mList[i_0].fabricSensitiveInt8u = element_0.fabricSensitiveInt8u.unsignedCharValue;
+       if (element_0.optionalFabricSensitiveInt8u != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].optionalFabricSensitiveInt8u.Emplace();
+                 definedValue_2 = element_0.optionalFabricSensitiveInt8u.unsignedCharValue;
+  }
+       if (element_0.nullableFabricSensitiveInt8u == nil) {
+         listHolder_0->mList[i_0].nullableFabricSensitiveInt8u.SetNull();
+       } else {
+         auto & nonNullValue_2 = listHolder_0->mList[i_0].nullableFabricSensitiveInt8u.SetNonNull();
+                 nonNullValue_2 = element_0.nullableFabricSensitiveInt8u.unsignedCharValue;
+  }
+       if (element_0.nullableOptionalFabricSensitiveInt8u != nil) {
+         auto & definedValue_2 = listHolder_0->mList[i_0].nullableOptionalFabricSensitiveInt8u.Emplace();
+           if (element_0.nullableOptionalFabricSensitiveInt8u == nil) {
+             definedValue_2.SetNull();
+           } else {
+             auto & nonNullValue_3 = definedValue_2.SetNonNull();
+                     nonNullValue_3 = element_0.nullableOptionalFabricSensitiveInt8u.unsignedCharValue;
+  }
+       }
+       listHolder_0->mList[i_0].fabricSensitiveCharString = AsCharSpan(element_0.fabricSensitiveCharString);
+                  listHolder_0->mList[i_0].fabricSensitiveStruct.a = element_0.fabricSensitiveStruct.a.unsignedCharValue;
+             listHolder_0->mList[i_0].fabricSensitiveStruct.b = element_0.fabricSensitiveStruct.b.boolValue;
+           listHolder_0->mList[i_0].fabricSensitiveStruct.c = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].fabricSensitiveStruct.c)>>(element_0.fabricSensitiveStruct.c.unsignedCharValue);
+       listHolder_0->mList[i_0].fabricSensitiveStruct.d = AsByteSpan(element_0.fabricSensitiveStruct.d);
+       listHolder_0->mList[i_0].fabricSensitiveStruct.e = AsCharSpan(element_0.fabricSensitiveStruct.e);
+             listHolder_0->mList[i_0].fabricSensitiveStruct.f = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].fabricSensitiveStruct.f)>>(element_0.fabricSensitiveStruct.f.unsignedCharValue);
+             listHolder_0->mList[i_0].fabricSensitiveStruct.g = element_0.fabricSensitiveStruct.g.floatValue;
+             listHolder_0->mList[i_0].fabricSensitiveStruct.h = element_0.fabricSensitiveStruct.h.doubleValue;
+       {
+         using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].fabricSensitiveInt8uList)>;
+         using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
+         if (element_0.fabricSensitiveInt8uList.count != 0) {
+           auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.fabricSensitiveInt8uList.count);
+           if (listHolder_2 == nullptr || listHolder_2->mList == nullptr) {
+             return CHIP_ERROR_INVALID_ARGUMENT;
+           }
+           listFreer.add(listHolder_2);
+           for (size_t i_2 = 0; i_2 < element_0.fabricSensitiveInt8uList.count; ++i_2) {
+             if ( ! [element_0.fabricSensitiveInt8uList[i_2] isKindOfClass: [NSNumber class]] ) {
+               // Wrong kind of value.
+               return CHIP_ERROR_INVALID_ARGUMENT;
+             }
+             auto element_2 = (NSNumber *)element_0.fabricSensitiveInt8uList[i_2];
+                     listHolder_2->mList[i_2] = element_2.unsignedCharValue;
+      }
+           listHolder_0->mList[i_0].fabricSensitiveInt8uList = ListType_2(listHolder_2->mList, element_0.fabricSensitiveInt8uList.count);
+         } else {
+           listHolder_0->mList[i_0].fabricSensitiveInt8uList = ListType_2();
+         }
+       }
+             listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
+      }
+              cppValue = ListType_0(listHolder_0->mList, value.count);
+            } else {
+              cppValue = ListType_0();
             }
+          }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -106300,30 +105094,24 @@ - (void)writeAttributeTimedWriteBooleanWithValue:(NSNumber * _Nonnull)value para
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-            if (!timedWriteTimeout.HasValue()) {
-                timedWriteTimeout.SetValue(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
+        if (!timedWriteTimeout.HasValue()) {
+          timedWriteTimeout.SetValue(MTR_DEFAULT_TIMED_INTERACTION_TIMEOUT_MS);
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::TimedWriteBoolean::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::TimedWriteBoolean::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -106373,27 +105161,21 @@ - (void)writeAttributeGeneralErrorBooleanWithValue:(NSNumber * _Nonnull)value pa
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::GeneralErrorBoolean::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::GeneralErrorBoolean::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -106443,27 +105225,21 @@ - (void)writeAttributeClusterErrorBooleanWithValue:(NSNumber * _Nonnull)value pa
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::ClusterErrorBoolean::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::ClusterErrorBoolean::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -106513,27 +105289,21 @@ - (void)writeAttributeUnsupportedWithValue:(NSNumber * _Nonnull)value params:(MT
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::Unsupported::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::Unsupported::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -106583,32 +105353,26 @@ - (void)writeAttributeNullableBooleanWithValue:(NSNumber * _Nullable)value param
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableBoolean::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.boolValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableBoolean::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.boolValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -106658,32 +105422,26 @@ - (void)writeAttributeNullableBitmap8WithValue:(NSNumber * _Nullable)value param
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableBitmap8::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableBitmap8::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -106733,32 +105491,26 @@ - (void)writeAttributeNullableBitmap16WithValue:(NSNumber * _Nullable)value para
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableBitmap16::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedShortValue);
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableBitmap16::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedShortValue);
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -106808,32 +105560,26 @@ - (void)writeAttributeNullableBitmap32WithValue:(NSNumber * _Nullable)value para
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableBitmap32::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedIntValue);
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableBitmap32::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedIntValue);
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -106883,32 +105629,26 @@ - (void)writeAttributeNullableBitmap64WithValue:(NSNumber * _Nullable)value para
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableBitmap64::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedLongLongValue);
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableBitmap64::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedLongLongValue);
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -106958,32 +105698,26 @@ - (void)writeAttributeNullableInt8uWithValue:(NSNumber * _Nullable)value params:
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt8u::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt8u::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -107033,32 +105767,26 @@ - (void)writeAttributeNullableInt16uWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt16u::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedShortValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt16u::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedShortValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -107108,32 +105836,26 @@ - (void)writeAttributeNullableInt24uWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt24u::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedIntValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt24u::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedIntValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -107183,32 +105905,26 @@ - (void)writeAttributeNullableInt32uWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt32u::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedIntValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt32u::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedIntValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -107258,32 +105974,26 @@ - (void)writeAttributeNullableInt40uWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt40u::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedLongLongValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt40u::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedLongLongValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -107333,32 +106043,26 @@ - (void)writeAttributeNullableInt48uWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt48u::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedLongLongValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt48u::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedLongLongValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -107408,32 +106112,26 @@ - (void)writeAttributeNullableInt56uWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt56u::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedLongLongValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt56u::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedLongLongValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -107483,32 +106181,26 @@ - (void)writeAttributeNullableInt64uWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt64u::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedLongLongValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt64u::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedLongLongValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -107558,32 +106250,26 @@ - (void)writeAttributeNullableInt8sWithValue:(NSNumber * _Nullable)value params:
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt8s::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.charValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt8s::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.charValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -107633,32 +106319,26 @@ - (void)writeAttributeNullableInt16sWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt16s::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.shortValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt16s::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.shortValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -107708,32 +106388,26 @@ - (void)writeAttributeNullableInt24sWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt24s::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.intValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt24s::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.intValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -107783,32 +106457,26 @@ - (void)writeAttributeNullableInt32sWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt32s::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.intValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt32s::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.intValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -107858,32 +106526,26 @@ - (void)writeAttributeNullableInt40sWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt40s::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.longLongValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt40s::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.longLongValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -107933,32 +106595,26 @@ - (void)writeAttributeNullableInt48sWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt48s::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.longLongValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt48s::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.longLongValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108008,32 +106664,26 @@ - (void)writeAttributeNullableInt56sWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt56s::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.longLongValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt56s::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.longLongValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108083,32 +106733,26 @@ - (void)writeAttributeNullableInt64sWithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableInt64s::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.longLongValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableInt64s::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.longLongValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108158,32 +106802,26 @@ - (void)writeAttributeNullableEnum8WithValue:(NSNumber * _Nullable)value params:
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableEnum8::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableEnum8::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108233,32 +106871,26 @@ - (void)writeAttributeNullableEnum16WithValue:(NSNumber * _Nullable)value params
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableEnum16::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedShortValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableEnum16::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedShortValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108308,32 +106940,26 @@ - (void)writeAttributeNullableFloatSingleWithValue:(NSNumber * _Nullable)value p
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableFloatSingle::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.floatValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableFloatSingle::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.floatValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108383,32 +107009,26 @@ - (void)writeAttributeNullableFloatDoubleWithValue:(NSNumber * _Nullable)value p
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableFloatDouble::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.doubleValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableFloatDouble::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.doubleValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108458,32 +107078,26 @@ - (void)writeAttributeNullableOctetStringWithValue:(NSData * _Nullable)value par
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableOctetString::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = AsByteSpan(value);
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableOctetString::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+              nonNullValue_0 = AsByteSpan(value);
+          }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108533,32 +107147,26 @@ - (void)writeAttributeNullableCharStringWithValue:(NSString * _Nullable)value pa
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableCharString::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = AsCharSpan(value);
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableCharString::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+              nonNullValue_0 = AsCharSpan(value);
+          }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108608,32 +107216,26 @@ - (void)writeAttributeNullableEnumAttrWithValue:(NSNumber * _Nullable)value para
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableEnumAttr::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableEnumAttr::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                  nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108683,39 +107285,33 @@ - (void)writeAttributeNullableStructWithValue:(MTRUnitTestingClusterSimpleStruct
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableStruct::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0.a = value.a.unsignedCharValue;
-                nonNullValue_0.b = value.b.boolValue;
-                nonNullValue_0.c = static_cast<std::remove_reference_t<decltype(nonNullValue_0.c)>>(value.c.unsignedCharValue);
-                nonNullValue_0.d = AsByteSpan(value.d);
-                nonNullValue_0.e = AsCharSpan(value.e);
-                nonNullValue_0.f = static_cast<std::remove_reference_t<decltype(nonNullValue_0.f)>>(value.f.unsignedCharValue);
-                nonNullValue_0.g = value.g.floatValue;
-                nonNullValue_0.h = value.h.doubleValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableStruct::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                         nonNullValue_0.a = value.a.unsignedCharValue;
+             nonNullValue_0.b = value.b.boolValue;
+           nonNullValue_0.c = static_cast<std::remove_reference_t<decltype(nonNullValue_0.c)>>(value.c.unsignedCharValue);
+       nonNullValue_0.d = AsByteSpan(value.d);
+       nonNullValue_0.e = AsCharSpan(value.e);
+             nonNullValue_0.f = static_cast<std::remove_reference_t<decltype(nonNullValue_0.f)>>(value.f.unsignedCharValue);
+             nonNullValue_0.g = value.g.floatValue;
+             nonNullValue_0.h = value.h.doubleValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108765,32 +107361,26 @@ - (void)writeAttributeNullableRangeRestrictedInt8uWithValue:(NSNumber * _Nullabl
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedCharValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt8u::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedCharValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108840,32 +107430,26 @@ - (void)writeAttributeNullableRangeRestrictedInt8sWithValue:(NSNumber * _Nullabl
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.charValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt8s::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.charValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108915,32 +107499,26 @@ - (void)writeAttributeNullableRangeRestrictedInt16uWithValue:(NSNumber * _Nullab
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.unsignedShortValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt16u::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.unsignedShortValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -108990,32 +107568,26 @@ - (void)writeAttributeNullableRangeRestrictedInt16sWithValue:(NSNumber * _Nullab
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
-
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
-            TypeInfo::Type cppValue;
-            if (value == nil) {
-                cppValue.SetNull();
-            } else {
-                auto & nonNullValue_0 = cppValue.SetNonNull();
-                nonNullValue_0 = value.shortValue;
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::NullableRangeRestrictedInt16s::TypeInfo;
+        TypeInfo::Type cppValue;
+          if (value == nil) {
+            cppValue.SetNull();
+          } else {
+            auto & nonNullValue_0 = cppValue.SetNonNull();
+                    nonNullValue_0 = value.shortValue;
+  }
+
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -109065,27 +107637,21 @@ - (void)writeAttributeWriteOnlyInt8uWithValue:(NSNumber * _Nonnull)value params:
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = UnitTesting::Attributes::WriteOnlyInt8u::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.unsignedCharValue;
+        ListFreer listFreer;
+        using TypeInfo = UnitTesting::Attributes::WriteOnlyInt8u::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.unsignedCharValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }
 
@@ -113317,27 +111883,21 @@ - (void)writeAttributeFlipFlopWithValue:(NSNumber * _Nonnull)value params:(MTRWr
     params = [params copy];
     value = [value copy];
 
-    auto * bridge = new MTRDefaultSuccessCallbackBridge(
-        self.callbackQueue,
-        ^(id _Nullable ignored, NSError * _Nullable error) {
-            completion(error);
-        },
-        ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
-            chip::Optional<uint16_t> timedWriteTimeout;
-            if (params != nil) {
-                if (params.timedWriteTimeout != nil) {
-                    timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
-                }
-            }
+    auto * bridge = new MTRDefaultSuccessCallbackBridge(self.callbackQueue, ^(id _Nullable ignored, NSError * _Nullable error) { completion(error); }, ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) {
+        chip::Optional<uint16_t> timedWriteTimeout;
+        if (params != nil) {
+          if (params.timedWriteTimeout != nil){
+            timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue);
+          }
+        }
 
-            ListFreer listFreer;
-            using TypeInfo = SampleMei::Attributes::FlipFlop::TypeInfo;
-            TypeInfo::Type cppValue;
-            cppValue = value.boolValue;
+        ListFreer listFreer;
+        using TypeInfo = SampleMei::Attributes::FlipFlop::TypeInfo;
+        TypeInfo::Type cppValue;
+                cppValue = value.boolValue;
 
-            chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
-            return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout);
-        });
+        chip::Controller::ClusterBase cppCluster(exchangeManager, session, self.endpoint);
+        return cppCluster.WriteAttribute<TypeInfo>(cppValue, bridge, successCb, failureCb, timedWriteTimeout); });
     std::move(*bridge).DispatchAction(self.device);
 }